grpc 1.62.0 → 1.64.0

data/src/core/{ext/xds → xds/grpc}/xds_bootstrap_grpc.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_GRPC_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_GRPC_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_BOOTSTRAP_GRPC_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_BOOTSTRAP_GRPC_H
 
 #include <map>
 #include <memory>
@@ -29,24 +27,26 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include "src/core/ext/xds/certificate_provider_store.h"
-#include "src/core/ext/xds/xds_audit_logger_registry.h"
-#include "src/core/ext/xds/xds_bootstrap.h"
-#include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
-#include "src/core/ext/xds/xds_http_filters.h"
-#include "src/core/ext/xds/xds_lb_policy_registry.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
+#include "src/core/xds/grpc/certificate_provider_store.h"
+#include "src/core/xds/grpc/xds_audit_logger_registry.h"
+#include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
+#include "src/core/xds/grpc/xds_http_filters.h"
+#include "src/core/xds/grpc/xds_lb_policy_registry.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {
 
-class GrpcXdsBootstrap : public XdsBootstrap {
+class GrpcXdsBootstrap final : public XdsBootstrap {
  public:
-  class GrpcNode : public Node {
+  class GrpcNode final : public Node {
    public:
     const std::string& id() const override { return id_; }
     const std::string& cluster() const override { return cluster_; }
@@ -76,7 +76,7 @@ class GrpcXdsBootstrap : public XdsBootstrap {
     Json::Object metadata_;
   };
 
-  class GrpcXdsServer : public XdsServer {
+  class GrpcXdsServer final : public XdsServer {
    public:
     const std::string& server_uri() const override { return server_uri_; }
 
@@ -102,10 +102,15 @@ class GrpcXdsBootstrap : public XdsBootstrap {
     std::set<std::string> server_features_;
   };
 
-  class GrpcAuthority : public Authority {
+  class GrpcAuthority final : public Authority {
    public:
-    const XdsServer* server() const override {
-      return servers_.empty() ? nullptr : &servers_[0];
+    std::vector<const XdsServer*> servers() const override {
+      std::vector<const XdsServer*> servers;
+      servers.reserve(servers_.size());
+      for (const auto& server : servers_) {
+        servers.emplace_back(&server);
+      }
+      return servers;
     }
 
     const std::string& client_listener_resource_name_template() const {
@@ -113,6 +118,8 @@ class GrpcXdsBootstrap : public XdsBootstrap {
     }
 
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
+                      ValidationErrors* errors);
 
    private:
     std::vector<GrpcXdsServer> servers_;
@@ -129,7 +136,15 @@ class GrpcXdsBootstrap : public XdsBootstrap {
 
   std::string ToString() const override;
 
-  const XdsServer& server() const override { return servers_[0]; }
+  std::vector<const XdsServer*> servers() const override {
+    std::vector<const XdsServer*> servers;
+    servers.reserve(servers_.size());
+    for (const auto& server : servers_) {
+      servers.emplace_back(&server);
+    }
+    return servers;
+  }
+
   const Node* node() const override {
     return node_.has_value() ? &*node_ : nullptr;
   }
@@ -179,4 +194,4 @@ class GrpcXdsBootstrap : public XdsBootstrap {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_GRPC_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_BOOTSTRAP_GRPC_H

data/src/core/{ext/xds → xds/grpc}/xds_certificate_provider.cc

@@ -16,16 +16,16 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_certificate_provider.h"
+#include "src/core/xds/grpc/xds_certificate_provider.h"
 
 #include <utility>
 
 #include "absl/functional/bind_front.h"
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
@@ -35,7 +35,7 @@ namespace grpc_core {
 
 namespace {
 
-class RootCertificatesWatcher
+class RootCertificatesWatcher final
     : public grpc_tls_certificate_distributor::TlsCertificatesWatcherInterface {
  public:
   // Takes a ref to \a parent instead of a raw pointer since the watcher is
@@ -68,7 +68,7 @@ class RootCertificatesWatcher
   RefCountedPtr<grpc_tls_certificate_distributor> parent_;
 };
 
-class IdentityCertificatesWatcher
+class IdentityCertificatesWatcher final
     : public grpc_tls_certificate_distributor::TlsCertificatesWatcherInterface {
  public:
   // Takes a ref to \a parent instead of a raw pointer since the watcher is
@@ -187,7 +187,7 @@ void XdsCertificateProvider::WatchStatusCallback(std::string cert_name,
     }
   } else if (!root_being_watched && root_cert_watcher_ != nullptr) {
     // Cancel root cert watch.
-    GPR_ASSERT(root_cert_provider_ != nullptr);
+    CHECK(root_cert_provider_ != nullptr);
     root_cert_provider_->distributor()->CancelTlsCertificatesWatch(
         root_cert_watcher_);
     root_cert_watcher_ = nullptr;
@@ -207,7 +207,7 @@ void XdsCertificateProvider::WatchStatusCallback(std::string cert_name,
           std::move(watcher), absl::nullopt, identity_cert_name_);
     }
   } else if (!identity_being_watched && identity_cert_watcher_ != nullptr) {
-    GPR_ASSERT(identity_cert_provider_ != nullptr);
+    CHECK(identity_cert_provider_ != nullptr);
     identity_cert_provider_->distributor()->CancelTlsCertificatesWatch(
         identity_cert_watcher_);
     identity_cert_watcher_ = nullptr;

data/src/core/{ext/xds → xds/grpc}/xds_certificate_provider.h

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_CERTIFICATE_PROVIDER_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_CERTIFICATE_PROVIDER_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_CERTIFICATE_PROVIDER_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_CERTIFICATE_PROVIDER_H
 
 #include <map>
 #include <memory>
@@ -31,6 +29,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -42,7 +41,7 @@
 
 namespace grpc_core {
 
-class XdsCertificateProvider : public grpc_tls_certificate_provider {
+class XdsCertificateProvider final : public grpc_tls_certificate_provider {
  public:
   // ctor for client side
   XdsCertificateProvider(
@@ -113,4 +112,4 @@ class XdsCertificateProvider : public grpc_tls_certificate_provider {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_CERTIFICATE_PROVIDER_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_CERTIFICATE_PROVIDER_H

data/src/core/{ext/xds → xds/grpc}/xds_client_grpc.cc

@@ -14,9 +14,7 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_client_grpc.h"
+#include "src/core/xds/grpc/xds_client_grpc.h"
 
 #include <algorithm>
 #include <cstddef>
@@ -38,17 +36,11 @@
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_api.h"
-#include "src/core/ext/xds/xds_bootstrap.h"
-#include "src/core/ext/xds/xds_bootstrap_grpc.h"
-#include "src/core/ext/xds/xds_channel_args.h"
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/ext/xds/xds_transport.h"
-#include "src/core/ext/xds/xds_transport_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/metrics.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -63,8 +55,14 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/error_utils.h"
-
-namespace grpc_core {
+#include "src/core/xds/grpc/upb_utils.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_transport_grpc.h"
+#include "src/core/xds/xds_client/xds_api.h"
+#include "src/core/xds/xds_client/xds_bootstrap.h"
+#include "src/core/xds/xds_client/xds_channel_args.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_transport.h"
 
 // If gRPC is built with -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="...", that string
 // will be appended to the user agent name reported to the xDS server.
@@ -84,21 +82,113 @@ namespace grpc_core {
 #define GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING ""
 #endif
 
+namespace grpc_core {
+
+namespace {
+
+// Metric labels.
+constexpr absl::string_view kMetricLabelXdsServer = "grpc.xds.server";
+constexpr absl::string_view kMetricLabelXdsAuthority = "grpc.xds.authority";
+constexpr absl::string_view kMetricLabelXdsResourceType =
+    "grpc.xds.resource_type";
+constexpr absl::string_view kMetricLabelXdsCacheState = "grpc.xds.cache_state";
+
+const auto kMetricResourceUpdatesValid =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.xds_client.resource_updates_valid",
+        "EXPERIMENTAL.  A counter of resources received that were considered "
+        "valid.  The counter will be incremented even for resources that "
+        "have not changed.",
+        "{resource}",
+        {kMetricLabelTarget, kMetricLabelXdsServer,
+         kMetricLabelXdsResourceType},
+        {}, false);
+
+const auto kMetricResourceUpdatesInvalid =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.xds_client.resource_updates_invalid",
+        "EXPERIMENTAL.  A counter of resources received that were considered "
+        "invalid.",
+        "{resource}",
+        {kMetricLabelTarget, kMetricLabelXdsServer,
+         kMetricLabelXdsResourceType},
+        {}, false);
+
+const auto kMetricServerFailure =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.xds_client.server_failure",
+        "EXPERIMENTAL.  A counter of xDS servers going from healthy to "
+        "unhealthy.  A server goes unhealthy when we have a connectivity "
+        "failure or when the ADS stream fails without seeing a response "
+        "message, as per gRFC A57.",
+        "{failure}", {kMetricLabelTarget, kMetricLabelXdsServer}, {}, false);
+
+const auto kMetricConnected =
+    GlobalInstrumentsRegistry::RegisterCallbackInt64Gauge(
+        "grpc.xds_client.connected",
+        "EXPERIMENTAL.  Whether or not the xDS client currently has a "
+        "working ADS stream to the xDS server.  For a given server, this "
+        "will be set to 0 when we have a connectivity failure or when the "
+        "ADS stream fails without seeing a response message, as per gRFC "
+        "A57.  It will be set to 1 when we receive the first response on "
+        "an ADS stream.",
+        "{bool}", {kMetricLabelTarget, kMetricLabelXdsServer}, {}, false);
+
+const auto kMetricResources =
+    GlobalInstrumentsRegistry::RegisterCallbackInt64Gauge(
+        "grpc.xds_client.resources", "EXPERIMENTAL.  Number of xDS resources.",
+        "{resource}",
+        {kMetricLabelTarget, kMetricLabelXdsAuthority,
+         kMetricLabelXdsResourceType, kMetricLabelXdsCacheState},
+        {}, false);
+
+}  // namespace
+
+//
+// GrpcXdsClient::MetricsReporter
+//
+
+class GrpcXdsClient::MetricsReporter final : public XdsMetricsReporter {
+ public:
+  explicit MetricsReporter(GrpcXdsClient& xds_client)
+      : xds_client_(xds_client) {}
+
+  void ReportResourceUpdates(absl::string_view xds_server,
+                             absl::string_view resource_type,
+                             uint64_t num_valid_resources,
+                             uint64_t num_invalid_resources) override {
+    xds_client_.stats_plugin_group_.AddCounter(
+        kMetricResourceUpdatesValid, num_valid_resources,
+        {xds_client_.key_, xds_server, resource_type}, {});
+    xds_client_.stats_plugin_group_.AddCounter(
+        kMetricResourceUpdatesInvalid, num_invalid_resources,
+        {xds_client_.key_, xds_server, resource_type}, {});
+  }
+
+  void ReportServerFailure(absl::string_view xds_server) override {
+    xds_client_.stats_plugin_group_.AddCounter(
+        kMetricServerFailure, 1, {xds_client_.key_, xds_server}, {});
+  }
+
+ private:
+  GrpcXdsClient& xds_client_;
+};
+
 //
 // GrpcXdsClient
 //
 
+constexpr absl::string_view GrpcXdsClient::kServerKey;
+
 namespace {
 
 Mutex* g_mu = new Mutex;
 const grpc_channel_args* g_channel_args ABSL_GUARDED_BY(*g_mu) = nullptr;
-GrpcXdsClient* g_xds_client ABSL_GUARDED_BY(*g_mu) = nullptr;
+// Key bytes live in clients so they outlive the entries in this map
+NoDestruct<std::map<absl::string_view, GrpcXdsClient*>> g_xds_client_map
+    ABSL_GUARDED_BY(*g_mu);
 char* g_fallback_bootstrap_config ABSL_GUARDED_BY(*g_mu) = nullptr;
 
-}  // namespace
-
-namespace {
-
 absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
   // First, try GRPC_XDS_BOOTSTRAP env var.
   auto path = GetEnv("GRPC_XDS_BOOTSTRAP");
@@ -136,23 +226,10 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
       "not defined");
 }
 
-std::vector<RefCountedPtr<GrpcXdsClient>> GetAllXdsClients() {
-  MutexLock lock(g_mu);
-  std::vector<RefCountedPtr<GrpcXdsClient>> xds_clients;
-  if (g_xds_client != nullptr) {
-    auto xds_client =
-        g_xds_client->RefIfNonZero(DEBUG_LOCATION, "DumpAllClientConfigs");
-    if (xds_client != nullptr) {
-      xds_clients.emplace_back(xds_client.TakeAsSubclass<GrpcXdsClient>());
-    }
-  }
-  return xds_clients;
-}
-
 }  // namespace
 
 absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
-    const ChannelArgs& args, const char* reason) {
+    absl::string_view key, const ChannelArgs& args, const char* reason) {
   // If getting bootstrap from channel args, create a local XdsClient
   // instance for the channel or server instead of using the global instance.
   absl::optional<absl::string_view> bootstrap_config = args.GetString(
@@ -164,13 +241,14 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
         GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_CLIENT_CHANNEL_ARGS);
     auto channel_args = ChannelArgs::FromC(xds_channel_args);
     return MakeRefCounted<GrpcXdsClient>(
-        std::move(*bootstrap), channel_args,
+        key, std::move(*bootstrap), channel_args,
         MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   }
   // Otherwise, use the global instance.
   MutexLock lock(g_mu);
-  if (g_xds_client != nullptr) {
-    auto xds_client = g_xds_client->RefIfNonZero(DEBUG_LOCATION, reason);
+  auto it = g_xds_client_map->find(key);
+  if (it != g_xds_client_map->end()) {
+    auto xds_client = it->second->RefIfNonZero(DEBUG_LOCATION, reason);
     if (xds_client != nullptr) {
       return xds_client.TakeAsSubclass<GrpcXdsClient>();
     }
@@ -188,12 +266,90 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   // Instantiate XdsClient.
   auto channel_args = ChannelArgs::FromC(g_channel_args);
   auto xds_client = MakeRefCounted<GrpcXdsClient>(
-      std::move(*bootstrap), channel_args,
+      key, std::move(*bootstrap), channel_args,
       MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
-  g_xds_client = xds_client.get();
+  g_xds_client_map->emplace(xds_client->key(), xds_client.get());
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    gpr_log(GPR_INFO, "[xds_client %p] Created xDS client for key %s",
+            xds_client.get(), std::string(key).c_str());
+  }
   return xds_client;
 }
 
+namespace {
+
+GlobalStatsPluginRegistry::StatsPluginGroup GetStatsPluginGroupForKey(
+    absl::string_view key) {
+  if (key == GrpcXdsClient::kServerKey) {
+    return GlobalStatsPluginRegistry::GetStatsPluginsForServer(ChannelArgs{});
+  }
+  // TODO(roth): How do we set the authority here?
+  experimental::StatsPluginChannelScope scope(key, "");
+  return GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
+}
+
+}  // namespace
+
+GrpcXdsClient::GrpcXdsClient(
+    absl::string_view key, std::unique_ptr<GrpcXdsBootstrap> bootstrap,
+    const ChannelArgs& args,
+    OrphanablePtr<XdsTransportFactory> transport_factory)
+    : XdsClient(
+          std::move(bootstrap), std::move(transport_factory),
+          grpc_event_engine::experimental::GetDefaultEventEngine(),
+          std::make_unique<MetricsReporter>(*this),
+          absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING,
+                       GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING),
+          absl::StrCat("C-core ", grpc_version_string(),
+                       GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING,
+                       GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING),
+          std::max(Duration::Zero(),
+                   args.GetDurationFromIntMillis(
+                           GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS)
+                       .value_or(Duration::Seconds(15)))),
+      key_(key),
+      certificate_provider_store_(MakeOrphanable<CertificateProviderStore>(
+          static_cast<const GrpcXdsBootstrap&>(this->bootstrap())
+              .certificate_providers())),
+      stats_plugin_group_(GetStatsPluginGroupForKey(key_)),
+      registered_metric_callback_(stats_plugin_group_.RegisterCallback(
+          [this](CallbackMetricReporter& reporter) {
+            ReportCallbackMetrics(reporter);
+          },
+          {kMetricConnected, kMetricResources})) {}
+
+void GrpcXdsClient::Orphaned() {
+  registered_metric_callback_.reset();
+  XdsClient::Orphaned();
+  MutexLock lock(g_mu);
+  auto it = g_xds_client_map->find(key_);
+  if (it != g_xds_client_map->end() && it->second == this) {
+    g_xds_client_map->erase(it);
+  }
+}
+
+grpc_pollset_set* GrpcXdsClient::interested_parties() const {
+  return reinterpret_cast<GrpcXdsTransportFactory*>(transport_factory())
+      ->interested_parties();
+}
+
+namespace {
+
+std::vector<RefCountedPtr<GrpcXdsClient>> GetAllXdsClients() {
+  MutexLock lock(g_mu);
+  std::vector<RefCountedPtr<GrpcXdsClient>> xds_clients;
+  for (const auto& key_client : *g_xds_client_map) {
+    auto xds_client =
+        key_client.second->RefIfNonZero(DEBUG_LOCATION, "DumpAllClientConfigs");
+    if (xds_client != nullptr) {
+      xds_clients.emplace_back(xds_client.TakeAsSubclass<GrpcXdsClient>());
+    }
+  }
+  return xds_clients;
+}
+
+}  // namespace
+
 // ABSL_NO_THREAD_SAFETY_ANALYSIS because we have to manually manage locks for
 // individual XdsClients and compiler struggles with checking the validity
 grpc_slice GrpcXdsClient::DumpAllClientConfigs()
@@ -211,6 +367,8 @@ grpc_slice GrpcXdsClient::DumpAllClientConfigs()
                                                                 arena.ptr());
     xds_client->mu()->Lock();
     xds_client->DumpClientConfig(&string_pool, arena.ptr(), client_config);
+    envoy_service_status_v3_ClientConfig_set_client_scope(
+        client_config, StdStringToUpbString(xds_client->key()));
   }
   // Serialize the upb message to bytes
   size_t output_length;
@@ -222,33 +380,17 @@ grpc_slice GrpcXdsClient::DumpAllClientConfigs()
   return grpc_slice_from_cpp_string(std::string(output, output_length));
 }
 
-GrpcXdsClient::GrpcXdsClient(
-    std::unique_ptr<GrpcXdsBootstrap> bootstrap, const ChannelArgs& args,
-    OrphanablePtr<XdsTransportFactory> transport_factory)
-    : XdsClient(
-          std::move(bootstrap), std::move(transport_factory),
-          grpc_event_engine::experimental::GetDefaultEventEngine(),
-          absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING,
-                       GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING),
-          absl::StrCat("C-core ", grpc_version_string(),
-                       GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING,
-                       GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING),
-          std::max(Duration::Zero(),
-                   args.GetDurationFromIntMillis(
-                           GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS)
-                       .value_or(Duration::Seconds(15)))),
-      certificate_provider_store_(MakeOrphanable<CertificateProviderStore>(
-          static_cast<const GrpcXdsBootstrap&>(this->bootstrap())
-              .certificate_providers())) {}
-
-GrpcXdsClient::~GrpcXdsClient() {
-  MutexLock lock(g_mu);
-  if (g_xds_client == this) g_xds_client = nullptr;
-}
-
-grpc_pollset_set* GrpcXdsClient::interested_parties() const {
-  return reinterpret_cast<GrpcXdsTransportFactory*>(transport_factory())
-      ->interested_parties();
+void GrpcXdsClient::ReportCallbackMetrics(CallbackMetricReporter& reporter) {
+  MutexLock lock(mu());
+  ReportResourceCounts([&](const ResourceCountLabels& labels, uint64_t count) {
+    reporter.Report(
+        kMetricResources, count,
+        {key_, labels.xds_authority, labels.resource_type, labels.cache_state},
+        {});
+  });
+  ReportServerConnections([&](absl::string_view xds_server, bool connected) {
+    reporter.Report(kMetricConnected, connected, {key_, xds_server}, {});
+  });
 }
 
 namespace internal {
@@ -258,9 +400,9 @@ void SetXdsChannelArgsForTest(grpc_channel_args* args) {
   g_channel_args = args;
 }
 
-void UnsetGlobalXdsClientForTest() {
+void UnsetGlobalXdsClientsForTest() {
   MutexLock lock(g_mu);
-  g_xds_client = nullptr;
+  g_xds_client_map->clear();
 }
 
 void SetXdsFallbackBootstrapConfig(const char* config) {

data/src/core/{ext/xds → xds/grpc}/xds_client_grpc.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_GRPC_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_GRPC_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_CLIENT_GRPC_H
+#define GRPC_SRC_CORE_XDS_GRPC_XDS_CLIENT_GRPC_H
 
 #include <memory>
 
@@ -25,28 +23,30 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/certificate_provider_store.h"
-#include "src/core/ext/xds/xds_bootstrap_grpc.h"
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/ext/xds/xds_transport.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/metrics.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/xds/grpc/certificate_provider_store.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/xds_client/xds_client.h"
+#include "src/core/xds/xds_client/xds_transport.h"
 
 namespace grpc_core {
 
-class GrpcXdsClient : public XdsClient {
+class GrpcXdsClient final : public XdsClient {
  public:
+  // The key to pass to GetOrCreate() for gRPC servers.
+  static constexpr absl::string_view kServerKey = "#server";
+
   // Factory function to get or create the global XdsClient instance.
   static absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GetOrCreate(
-      const ChannelArgs& args, const char* reason);
-
-  // Builds ClientStatusResponse containing all resources from all XdsClients
-  static grpc_slice DumpAllClientConfigs();
+      absl::string_view key, const ChannelArgs& args, const char* reason);
 
   // Do not instantiate directly -- use GetOrCreate() instead.
   // TODO(roth): The transport factory is injectable here to support
@@ -60,10 +60,10 @@ class GrpcXdsClient : public XdsClient {
   // work for callers that use interested_parties() but not for callers
   // that also use certificate_provider_store(), but we should consider
   // alternatives for that case as well.
-  GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
+  GrpcXdsClient(absl::string_view key,
+                std::unique_ptr<GrpcXdsBootstrap> bootstrap,
                 const ChannelArgs& args,
                 OrphanablePtr<XdsTransportFactory> transport_factory);
-  ~GrpcXdsClient() override;
 
   // Helpers for encoding the XdsClient object in channel args.
   static absl::string_view ChannelArgName() {
@@ -79,13 +79,26 @@ class GrpcXdsClient : public XdsClient {
     return *certificate_provider_store_;
   }
 
+  absl::string_view key() const { return key_; }
+
+  // Builds ClientStatusResponse containing all resources from all XdsClients
+  static grpc_slice DumpAllClientConfigs();
+
  private:
+  class MetricsReporter;
+
+  void ReportCallbackMetrics(CallbackMetricReporter& reporter);
+  void Orphaned() override;
+
+  std::string key_;
   OrphanablePtr<CertificateProviderStore> certificate_provider_store_;
+  GlobalStatsPluginRegistry::StatsPluginGroup stats_plugin_group_;
+  std::unique_ptr<RegisteredMetricCallback> registered_metric_callback_;
 };
 
 namespace internal {
 void SetXdsChannelArgsForTest(grpc_channel_args* args);
-void UnsetGlobalXdsClientForTest();
+void UnsetGlobalXdsClientsForTest();
 // Sets bootstrap config to be used when no env var is set.
 // Does not take ownership of config.
 void SetXdsFallbackBootstrapConfig(const char* config);
@@ -93,4 +106,4 @@ void SetXdsFallbackBootstrapConfig(const char* config);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_CLIENT_GRPC_H
+#endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_CLIENT_GRPC_H