grpc 1.80.0 → 1.81.0

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

@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#include "src/core/load_balancing/xds/cds.h"
+
 #include <grpc/grpc_security.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/json.h>
@@ -69,6 +71,98 @@ namespace grpc_core {
 
 namespace {
 
+// We need at least one priority for each discovery mechanism, just so that we
+// have a child in which to create the xds_cluster_impl policy.  This ensures
+// that we properly handle the case of a discovery mechanism dropping 100% of
+// calls, the OnError() case, and the OnResourceDoesNotExist() case.
+const XdsEndpointResource::PriorityList& GetUpdatePriorityList(
+    const XdsEndpointResource* update) {
+  static const NoDestruct<XdsEndpointResource::PriorityList>
+      kPriorityListWithEmptyPriority(1);
+  if (update == nullptr || update->priorities.empty()) {
+    return *kPriorityListWithEmptyPriority;
+  }
+  return update->priorities;
+}
+
+}  // namespace
+
+void CdsChildNameState::Update(
+    const XdsConfig::ClusterConfig* old_cluster,
+    const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) {
+  // First, build some maps from locality to child number and the reverse
+  // from old_cluster and current state.
+  std::map<XdsLocalityName*, size_t /*child_number*/, XdsLocalityName::Less>
+      locality_child_map;
+  std::map<size_t, std::set<XdsLocalityName*, XdsLocalityName::Less>>
+      child_locality_map;
+  if (old_cluster != nullptr) {
+    auto* old_endpoint_config =
+        std::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
+            &old_cluster->children);
+    if (old_endpoint_config != nullptr) {
+      const auto& prev_priority_list =
+          GetUpdatePriorityList(old_endpoint_config->endpoints.get());
+      for (size_t priority = 0; priority < prev_priority_list.size();
+           ++priority) {
+        size_t child_number = priority_child_numbers_[priority];
+        const auto& localities = prev_priority_list[priority].localities;
+        for (const auto& [locality_name, _] : localities) {
+          locality_child_map[locality_name] = child_number;
+          child_locality_map[child_number].insert(locality_name);
+        }
+      }
+    }
+  }
+  // Now construct new priority child numbers for the new cluster based on
+  // the maps constructed above.
+  std::vector<size_t> new_priority_child_numbers;
+  const XdsEndpointResource::PriorityList& priority_list =
+      GetUpdatePriorityList(endpoint_config.endpoints.get());
+  for (size_t priority = 0; priority < priority_list.size(); ++priority) {
+    const auto& localities = priority_list[priority].localities;
+    std::optional<size_t> child_number;
+    // If one of the localities in this priority already existed, reuse its
+    // child number.
+    for (const auto& [locality_name, _] : localities) {
+      if (!child_number.has_value()) {
+        auto it = locality_child_map.find(locality_name);
+        if (it != locality_child_map.end()) {
+          child_number = it->second;
+          locality_child_map.erase(it);
+          // Remove localities that *used* to be in this child number, so
+          // that we don't incorrectly reuse this child number for a
+          // subsequent priority.
+          for (XdsLocalityName* old_locality :
+               child_locality_map[*child_number]) {
+            locality_child_map.erase(old_locality);
+          }
+        }
+      } else {
+        // Remove all localities that are now in this child number, so
+        // that we don't accidentally reuse this child number for a
+        // subsequent priority.
+        locality_child_map.erase(locality_name);
+      }
+    }
+    // If we didn't find an existing child number, assign a new one.
+    if (!child_number.has_value()) {
+      for (child_number = next_available_child_number_;
+           child_locality_map.find(*child_number) != child_locality_map.end();
+           ++(*child_number)) {
+      }
+      next_available_child_number_ = *child_number + 1;
+      // Add entry so we know that the child number is in use.
+      // (Don't need to add the list of localities, since we won't use them.)
+      child_locality_map[*child_number];
+    }
+    new_priority_child_numbers.push_back(*child_number);
+  }
+  priority_child_numbers_ = std::move(new_priority_child_numbers);
+}
+
+namespace {
+
 // TODO(roth): Remove this after the 1.63 release.
 bool XdsAggregateClusterBackwardCompatibilityEnabled() {
   auto value = GetEnv("GRPC_XDS_AGGREGATE_CLUSTER_BACKWARD_COMPAT");
@@ -160,31 +254,10 @@ class CdsLb final : public LoadBalancingPolicy {
     }
   };
 
-  // State used to retain child policy names for the priority policy.
-  struct ChildNameState {
-    std::vector<size_t /*child_number*/> priority_child_numbers;
-    size_t next_available_child_number = 0;
-
-    void Reset() {
-      priority_child_numbers.clear();
-      next_available_child_number = 0;
-    }
-  };
-
   ~CdsLb() override;
 
   void ShutdownLocked() override;
 
-  // Computes child numbers for new_cluster, reusing child numbers
-  // from old_cluster and child_name_state_ in an intelligent
-  // way to avoid unnecessary churn.
-  ChildNameState ComputeChildNames(
-      const XdsConfig::ClusterConfig* old_cluster,
-      const XdsConfig::ClusterConfig& new_cluster,
-      const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) const;
-
-  std::string GetChildPolicyName(const std::string& cluster, size_t priority);
-
   Json CreateChildPolicyConfigForLeafCluster(
       const XdsConfig::ClusterConfig& new_cluster,
       const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config,
@@ -202,7 +275,7 @@ class CdsLb final : public LoadBalancingPolicy {
   // Cluster subscription, for dynamic clusters (e.g., RLS).
   RefCountedPtr<XdsDependencyManager::ClusterSubscription> subscription_;
 
-  ChildNameState child_name_state_;
+  CdsChildNameState child_name_state_;
 
   // Child LB policy.
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
@@ -238,20 +311,6 @@ void CdsLb::ExitIdleLocked() {
   if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
 }
 
-// We need at least one priority for each discovery mechanism, just so that we
-// have a child in which to create the xds_cluster_impl policy.  This ensures
-// that we properly handle the case of a discovery mechanism dropping 100% of
-// calls, the OnError() case, and the OnResourceDoesNotExist() case.
-const XdsEndpointResource::PriorityList& GetUpdatePriorityList(
-    const XdsEndpointResource* update) {
-  static const NoDestruct<XdsEndpointResource::PriorityList>
-      kPriorityListWithEmptyPriority(1);
-  if (update == nullptr || update->priorities.empty()) {
-    return *kPriorityListWithEmptyPriority;
-  }
-  return update->priorities;
-}
-
 std::string MakeChildPolicyName(absl::string_view cluster,
                                 size_t child_number) {
   return absl::StrCat("{cluster=", cluster, ", child_number=", child_number,
@@ -430,13 +489,12 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
       // Leaf cluster.
       [&](const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) {
         // Compute new child numbers.
-        child_name_state_ = ComputeChildNames(
-            old_cluster_config, *new_cluster_config, endpoint_config);
+        child_name_state_.Update(old_cluster_config, endpoint_config);
         // Populate addresses and resolution_note for child policy.
         update_args.addresses = std::make_shared<PriorityEndpointIterator>(
             cluster_name_, new_cluster_config->cluster->use_http_connect,
             endpoint_config.endpoints,
-            child_name_state_.priority_child_numbers);
+            child_name_state_.priority_child_numbers());
         std::vector<absl::string_view> resolution_notes;
         if (!args.resolution_note.empty()) {
           resolution_notes.emplace_back(args.resolution_note);
@@ -504,86 +562,6 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
   return child_policy_->UpdateLocked(std::move(update_args));
 }
 
-CdsLb::ChildNameState CdsLb::ComputeChildNames(
-    const XdsConfig::ClusterConfig* old_cluster,
-    const XdsConfig::ClusterConfig& new_cluster,
-    const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) const {
-  GRPC_CHECK(!std::holds_alternative<XdsConfig::ClusterConfig::AggregateConfig>(
-      new_cluster.children));
-  // First, build some maps from locality to child number and the reverse
-  // from old_cluster and child_name_state_.
-  std::map<XdsLocalityName*, size_t /*child_number*/, XdsLocalityName::Less>
-      locality_child_map;
-  std::map<size_t, std::set<XdsLocalityName*, XdsLocalityName::Less>>
-      child_locality_map;
-  if (old_cluster != nullptr) {
-    auto* old_endpoint_config =
-        std::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
-            &old_cluster->children);
-    if (old_endpoint_config != nullptr) {
-      const auto& prev_priority_list =
-          GetUpdatePriorityList(old_endpoint_config->endpoints.get());
-      for (size_t priority = 0; priority < prev_priority_list.size();
-           ++priority) {
-        size_t child_number =
-            child_name_state_.priority_child_numbers[priority];
-        const auto& localities = prev_priority_list[priority].localities;
-        for (const auto& [locality_name, _] : localities) {
-          locality_child_map[locality_name] = child_number;
-          child_locality_map[child_number].insert(locality_name);
-        }
-      }
-    }
-  }
-  // Now construct new state containing priority child numbers for the new
-  // cluster based on the maps constructed above.
-  ChildNameState new_child_name_state;
-  new_child_name_state.next_available_child_number =
-      child_name_state_.next_available_child_number;
-  const XdsEndpointResource::PriorityList& priority_list =
-      GetUpdatePriorityList(endpoint_config.endpoints.get());
-  for (size_t priority = 0; priority < priority_list.size(); ++priority) {
-    const auto& localities = priority_list[priority].localities;
-    std::optional<size_t> child_number;
-    // If one of the localities in this priority already existed, reuse its
-    // child number.
-    for (const auto& [locality_name, _] : localities) {
-      if (!child_number.has_value()) {
-        auto it = locality_child_map.find(locality_name);
-        if (it != locality_child_map.end()) {
-          child_number = it->second;
-          locality_child_map.erase(it);
-          // Remove localities that *used* to be in this child number, so
-          // that we don't incorrectly reuse this child number for a
-          // subsequent priority.
-          for (XdsLocalityName* old_locality :
-               child_locality_map[*child_number]) {
-            locality_child_map.erase(old_locality);
-          }
-        }
-      } else {
-        // Remove all localities that are now in this child number, so
-        // that we don't accidentally reuse this child number for a
-        // subsequent priority.
-        locality_child_map.erase(locality_name);
-      }
-    }
-    // If we didn't find an existing child number, assign a new one.
-    if (!child_number.has_value()) {
-      for (child_number = new_child_name_state.next_available_child_number;
-           child_locality_map.find(*child_number) != child_locality_map.end();
-           ++(*child_number)) {
-      }
-      new_child_name_state.next_available_child_number = *child_number + 1;
-      // Add entry so we know that the child number is in use.
-      // (Don't need to add the list of localities, since we won't use them.)
-      child_locality_map[*child_number];
-    }
-    new_child_name_state.priority_child_numbers.push_back(*child_number);
-  }
-  return new_child_name_state;
-}
-
 Json CdsLb::CreateChildPolicyConfigForLeafCluster(
     const XdsConfig::ClusterConfig& new_cluster,
     const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config,
@@ -609,9 +587,9 @@ Json CdsLb::CreateChildPolicyConfigForLeafCluster(
       GetUpdatePriorityList(endpoint_config.endpoints.get());
   for (size_t priority = 0; priority < priority_list.size(); ++priority) {
     // Add priority entry, with the appropriate child name.
-    std::string child_name =
-        MakeChildPolicyName(cluster_name_.as_string_view(),
-                            child_name_state_.priority_child_numbers[priority]);
+    std::string child_name = MakeChildPolicyName(
+        cluster_name_.as_string_view(),
+        child_name_state_.priority_child_numbers()[priority]);
     priority_priorities.emplace_back(Json::FromString(child_name));
     Json::Object child_config = {{"config", xds_lb_policy}};
     if (!is_logical_dns) {

data/src/core/load_balancing/xds/cds.h

@@ -0,0 +1,58 @@
+//
+// Copyright 2019 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H
+
+#include <vector>
+
+#include "src/core/resolver/xds/xds_config.h"
+
+namespace grpc_core {
+
+// State used to retain child policy names for the priority policy.
+// Exposed for testing purposes only.
+class CdsChildNameState {
+ public:
+  // Each index in the vector is a priority.  The value for a given
+  // priority is the child number for that priority.
+  const std::vector<size_t /*child_number*/>& priority_child_numbers() const {
+    return priority_child_numbers_;
+  }
+
+  size_t next_available_child_number() const {
+    return next_available_child_number_;
+  }
+
+  // Updates child numbers for endpoint_config, reusing child numbers
+  // from old_cluster and current state in an intelligent way to avoid
+  // unnecessary churn.
+  void Update(const XdsConfig::ClusterConfig* old_cluster,
+              const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config);
+
+  void Reset() {
+    priority_child_numbers_.clear();
+    next_available_child_number_ = 0;
+  }
+
+ private:
+  std::vector<size_t /*child_number*/> priority_child_numbers_;
+  size_t next_available_child_number_ = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_XDS_CDS_H

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -88,6 +88,10 @@ void RegisterBuiltins(CoreConfiguration::Builder* builder) {
       ->RegisterFilter(GRPC_SERVER_CHANNEL, &Server::kServerTopFilter)
       .SkipV3()
       .BeforeAll();
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_VIRTUAL_CHANNEL, &Server::kServerTopFilter)
+      .SkipV3()
+      .BeforeAll();
 }
 
 }  // namespace

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

@@ -818,7 +818,7 @@ static void on_txt_done_locked(void* arg, int status, int /*timeouts*/,
   if (status != ARES_SUCCESS) goto fail;
   // Find service config in TXT record.
   for (result = reply; result != nullptr; result = result->next) {
-    if (result->record_start &&
+    if (result->record_start && result->length >= prefix_len &&
         memcmp(result->txt, g_service_config_attribute_prefix, prefix_len) ==
             0) {
       break;

data/src/core/server/server.cc

@@ -72,6 +72,7 @@
 #include "src/core/lib/surface/legacy_channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/telemetry/metrics.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
@@ -106,16 +107,6 @@ void Server::ListenerState::ConfigFetcherWatcher::UpdateConnectionManager(
     if (listener_state_->server_->ShutdownCalled()) {
       return;
     }
-    RefCountedPtr<Blackboard> new_blackboard;
-    for (auto& blackboard_shard : listener_state_->blackboards_) {
-      MutexLock lock(&blackboard_shard.mu);
-      if (new_blackboard == nullptr) {
-        new_blackboard = MakeRefCounted<Blackboard>();
-        listener_state_->connection_manager_->UpdateBlackboard(
-            blackboard_shard.blackboard.get(), new_blackboard.get());
-      }
-      blackboard_shard.blackboard = new_blackboard;
-    }
     listener_state_->is_serving_ = true;
     if (listener_state_->started_) return;
     listener_state_->started_ = true;
@@ -142,8 +133,7 @@ Server::ListenerState::ListenerState(RefCountedPtr<Server> server,
       event_engine_(
           server_->channel_args()
               .GetObject<grpc_event_engine::experimental::EventEngine>()),
-      listener_(std::move(l)),
-      blackboards_(PerCpuOptions().SetMaxShards(16)) {
+      listener_(std::move(l)) {
   auto max_allowed_incoming_connections =
       server_->channel_args().GetInt(GRPC_ARG_MAX_ALLOWED_INCOMING_CONNECTIONS);
   if (max_allowed_incoming_connections.has_value()) {
@@ -289,19 +279,6 @@ void Server::ListenerState::RemoveLogicalConnection(
   }
 }
 
-grpc_error_handle Server::ListenerState::SetupTransport(
-    Transport* transport, grpc_pollset* accepting_pollset,
-    const ChannelArgs& args) {
-  RefCountedPtr<Blackboard> blackboard;
-  {
-    auto& blackboard_shard = blackboards_.this_cpu();
-    MutexLock lock(&blackboard_shard.mu);
-    blackboard = blackboard_shard.blackboard;
-  }
-  return server_->SetupTransport(transport, accepting_pollset, args,
-                                 blackboard.get());
-}
-
 void Server::ListenerState::DrainConnectionsLocked() {
   if (connections_.empty()) {
     return;
@@ -1176,14 +1153,14 @@ auto Server::MatchAndPublishCall(CallHandler call_handler) {
 
 absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>
 Server::MakeCallDestination(const ChannelArgs& args,
-                            const Blackboard* blackboard) {
-  InterceptionChainBuilder builder(args, blackboard);
+                            grpc_channel_stack_type channel_stack_type) {
+  InterceptionChainBuilder builder(args);
   // TODO(ctiller): find a way to avoid adding a server ref per call
   builder.AddOnClientInitialMetadata([self = Ref()](ClientMetadata& md) {
     self->SetRegisteredMethodOnMetadata(md);
   });
   CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
-      GRPC_SERVER_CHANNEL, builder);
+      channel_stack_type, builder);
   return builder.Build(
       MakeCallDestinationFromHandlerFunction([this](CallHandler handler) {
         return MatchAndPublishCall(std::move(handler));
@@ -1192,13 +1169,14 @@ Server::MakeCallDestination(const ChannelArgs& args,
 
 Server::Server(const ChannelArgs& args)
     : channelz::DataSource(CreateChannelzNode(args)),
-      channel_args_(args),
+      channel_args_(args.SetObject(
+          GlobalStatsPluginRegistry::GetStatsPluginsForServer(args))),
       channelz_node_(channelz::DataSource::channelz_node() == nullptr
                          ? nullptr
                          : channelz::DataSource::channelz_node()
                                ->RefAsSubclass<channelz::ServerNode>()),
-      server_call_tracer_factory_(ServerCallTracerFactory::Get(args)),
-      compression_options_(CompressionOptionsFromChannelArgs(args)),
+      server_call_tracer_factory_(ServerCallTracerFactory::Get(channel_args_)),
+      compression_options_(CompressionOptionsFromChannelArgs(channel_args_)),
       max_time_in_pending_queue_(Duration::Seconds(
           channel_args_
               .GetInt(GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS)
@@ -1311,8 +1289,14 @@ void Server::Start() {
 
 grpc_error_handle Server::SetupTransport(Transport* transport,
                                          grpc_pollset* accepting_pollset,
-                                         const ChannelArgs& args,
-                                         const Blackboard* blackboard) {
+                                         const ChannelArgs& args) {
+  return SetupTransport(transport, accepting_pollset, args,
+                        GRPC_SERVER_CHANNEL);
+}
+
+grpc_error_handle Server::SetupTransport(
+    Transport* transport, grpc_pollset* accepting_pollset,
+    const ChannelArgs& args, grpc_channel_stack_type channel_stack_type) {
   GRPC_LATENT_SEE_SCOPE("Server::SetupTransport");
   // Create channel.
   global_stats().IncrementServerChannelsCreated();
@@ -1325,7 +1309,7 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
     auto destination = MakeCallDestination(
         args.SetObject(transport).SetObject<channelz::BaseNode>(
             transport->GetSocketNode()),
-        blackboard);
+        channel_stack_type);
     if (!destination.ok()) {
       return absl_status_to_grpc_error(destination.status());
     }
@@ -1349,7 +1333,7 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
         "",
         args.SetObject(transport).SetObject<channelz::BaseNode>(
             transport->GetSocketNode()),
-        GRPC_SERVER_CHANNEL, blackboard);
+        channel_stack_type);
     if (!channel.ok()) {
       return absl_status_to_grpc_error(channel.status());
     }

data/src/core/server/server.h

@@ -38,7 +38,6 @@
 
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -61,7 +60,6 @@
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/orphanable.h"
-#include "src/core/util/per_cpu.h"
 #include "src/core/util/random_early_detection.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
@@ -89,9 +87,6 @@ class ServerConfigFetcher
     virtual absl::StatusOr<grpc_core::ChannelArgs>
     UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
                                    grpc_endpoint* tcp) = 0;
-
-    virtual void UpdateBlackboard(const Blackboard* old_blackboard,
-                                  Blackboard* new_blackboard) = 0;
   };
 
   class WatcherInterface {
@@ -253,10 +248,6 @@ class Server : public ServerInterface,
     void RemoveLogicalConnection(
         ListenerInterface::LogicalConnection* connection);
 
-    grpc_error_handle SetupTransport(Transport* transport,
-                                     grpc_pollset* accepting_pollset,
-                                     const ChannelArgs& args);
-
     const MemoryQuotaRefPtr& memory_quota() const { return memory_quota_; }
 
     const ConnectionQuotaRefPtr& connection_quota() const {
@@ -293,11 +284,6 @@ class Server : public ServerInterface,
       grpc_core::Timestamp timestamp;
     };
 
-    struct BlackboardShard {
-      Mutex mu;
-      RefCountedPtr<Blackboard> blackboard ABSL_GUARDED_BY(&mu);
-    };
-
     void DrainConnectionsLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
     void OnDrainGraceTimer();
@@ -315,7 +301,6 @@ class Server : public ServerInterface,
     OrphanablePtr<ListenerInterface> listener_;
     grpc_closure destroy_done_;
     ConfigFetcherWatcher* config_fetcher_watcher_ = nullptr;
-    PerCpu<BlackboardShard> blackboards_;
     Mutex mu_;  // We could share this mutex with Listener implementations. It's
                 // a tradeoff between increased memory requirement and more
                 // granular critical regions.
@@ -372,10 +357,17 @@ class Server : public ServerInterface,
   // Sets up a transport.  Creates a channel stack and binds the transport to
   // the server.  Called from the listener when a new connection is accepted.
   // Takes ownership of a ref on resource_user from the caller.
+  grpc_error_handle SetupTransport(Transport* transport,
+                                   grpc_pollset* accepting_pollset,
+                                   const ChannelArgs& args)
+      ABSL_LOCKS_EXCLUDED(mu_global_);
+
+  // Variant of SetupTransport that allows for specifying the channel stack
+  // type.
   grpc_error_handle SetupTransport(Transport* transport,
                                    grpc_pollset* accepting_pollset,
                                    const ChannelArgs& args,
-                                   const Blackboard* blackboard = nullptr)
+                                   grpc_channel_stack_type channel_stack_type)
       ABSL_LOCKS_EXCLUDED(mu_global_);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
@@ -661,7 +653,7 @@ class Server : public ServerInterface,
                                             ClientMetadataHandle md);
   auto MatchAndPublishCall(CallHandler call_handler);
   absl::StatusOr<RefCountedPtr<UnstartedCallDestination>> MakeCallDestination(
-      const ChannelArgs& args, const Blackboard* blackboard);
+      const ChannelArgs& args, grpc_channel_stack_type channel_stack_type);
 
   ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;

data/src/core/server/xds_server_config_fetcher.cc

@@ -211,9 +211,6 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
       const ChannelArgs& args, grpc_endpoint* tcp) override;
 
-  void UpdateBlackboard(const Blackboard* old_blackboard,
-                        Blackboard* new_blackboard) override;
-
   // Invoked by ListenerWatcher to start fetching referenced RDS resources.
   void StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ListenerWatcher::mu_);
@@ -1108,27 +1105,6 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   return args;
 }
 
-void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    UpdateBlackboard(const Blackboard* old_blackboard,
-                     Blackboard* new_blackboard) {
-  const auto& http_filter_registry =
-      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-          .http_filter_registry();
-  ForEachFilterChain(
-      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
-        auto& hcm = filter_chain_data.http_connection_manager;
-        for (const auto& http_filter : hcm.http_filters) {
-          const XdsHttpFilterImpl* filter_impl =
-              http_filter_registry.GetFilterForTopLevelType(
-                  http_filter.config_proto_type);
-          GRPC_CHECK_NE(filter_impl,
-                        nullptr);  // Enforced in config validation.
-          filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
-                                        new_blackboard);
-        }
-      });
-}
-
 //
 // XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::XdsServerConfigSelector
 //

data/src/core/telemetry/metrics.cc

@@ -14,6 +14,7 @@
 
 #include "src/core/telemetry/metrics.h"
 
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
 #include <memory>
@@ -174,6 +175,19 @@ GlobalStatsPluginRegistry::GetStatsPluginsForChannel(
       group->AddStatsPlugin(node->plugin, std::move(config));
     }
   }
+  using StatsPluginList =
+      std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>;
+  auto* stats_plugin_list =
+      static_cast<StatsPluginList*>(scope.experimental_args().GetVoidPointer(
+          GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS));
+  if (stats_plugin_list != nullptr) {
+    for (const auto& plugin : **stats_plugin_list) {
+      auto [is_enabled, config] = plugin->IsEnabledForChannel(scope);
+      if (is_enabled) {
+        group->AddStatsPlugin(plugin, std::move(config));
+      }
+    }
+  }
   group->Finish();
   return group;
 }
@@ -188,6 +202,18 @@ GlobalStatsPluginRegistry::GetStatsPluginsForServer(const ChannelArgs& args) {
       group->AddStatsPlugin(node->plugin, std::move(config));
     }
   }
+  using StatsPluginList =
+      std::shared_ptr<std::vector<std::shared_ptr<StatsPlugin>>>;
+  auto* stats_plugin_list =
+      args.GetPointer<StatsPluginList>(GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
+  if (stats_plugin_list != nullptr) {
+    for (const auto& plugin : **stats_plugin_list) {
+      auto [is_enabled, config] = plugin->IsEnabledForServer(args);
+      if (is_enabled) {
+        group->AddStatsPlugin(plugin, std::move(config));
+      }
+    }
+  }
   group->Finish();
   return group;
 }