grpc 1.72.0 → 1.74.1

data/src/core/client_channel/subchannel.cc

@@ -422,11 +422,21 @@ class Subchannel::ConnectedSubchannelStateWatcher final
         if (c->channelz_node() != nullptr) {
           c->channelz_node()->SetChildSocket(nullptr);
         }
-        // Even though we're reporting IDLE instead of TRANSIENT_FAILURE here,
-        // pass along the status from the transport, since it may have
-        // keepalive info attached to it that the channel needs.
-        // TODO(roth): Consider whether there's a cleaner way to do this.
-        c->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, status);
+        // If the subchannel was created from an endpoint, then we report
+        // TRANSIENT_FAILURE here instead of IDLE. The subchannel will never
+        // leave TRANSIENT_FAILURE state, because there is no way for us to
+        // establish a new connection.
+        //
+        // Otherwise, we report IDLE here. Note that even though we're not
+        // reporting TRANSIENT_FAILURE, we pass along the status from the
+        // transport, since it may have keepalive info attached to it that the
+        // channel needs.
+        // TODO(roth): Consider whether there's a cleaner way to propagate the
+        // keepalive info.
+        c->SetConnectivityStateLocked(c->created_from_endpoint_
+                                          ? GRPC_CHANNEL_TRANSIENT_FAILURE
+                                          : GRPC_CHANNEL_IDLE,
+                                      status);
         c->backoff_.Reset();
       }
     }
@@ -452,10 +462,8 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
   for (const auto& watcher : watchers_) {
-    subchannel_->work_serializer_.Run([watcher = watcher->Ref(), state,
-                                       status]() mutable {
-      auto* watcher_ptr = watcher.get();
-      watcher_ptr->OnConnectivityStateChange(std::move(watcher), state, status);
+    subchannel_->work_serializer_.Run([watcher, state, status]() {
+      watcher->OnConnectivityStateChange(state, status);
     });
   }
 }
@@ -511,6 +519,7 @@ Subchannel::Subchannel(SubchannelKey key,
                                      ? "Subchannel"
                                      : nullptr),
       key_(std::move(key)),
+      created_from_endpoint_(args.Contains(GRPC_ARG_SUBCHANNEL_ENDPOINT)),
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
@@ -548,17 +557,15 @@ Subchannel::Subchannel(SubchannelKey key,
         grpc_sockaddr_to_uri(&key_.address())
             .value_or("<unknown address type>"),
         channel_tracer_max_memory);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("subchannel created"));
+    GRPC_CHANNELZ_LOG(channelz_node_) << "subchannel created";
+    channelz_node_->SetChannelArgs(args_);
+    args_ = args_.SetObject<channelz::BaseNode>(channelz_node_);
   }
 }
 
 Subchannel::~Subchannel() {
   if (channelz_node_ != nullptr) {
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Subchannel destroyed"));
+    GRPC_CHANNELZ_LOG(channelz_node_) << "Subchannel destroyed";
     channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
   }
   connector_.reset();
@@ -578,6 +585,15 @@ RefCountedPtr<Subchannel> Subchannel::Create(
     return c;
   }
   c = MakeRefCounted<Subchannel>(std::move(key), std::move(connector), args);
+  if (c->created_from_endpoint_) {
+    // We don't interact with the subchannel pool in this case.
+    // Instead, we unconditionally return the newly created subchannel.
+    // Before returning, we explicitly trigger a connection attempt
+    // by calling RequestConnection(), which sets the subchannel’s
+    // connectivity state to CONNECTING.
+    c->RequestConnection();
+    return c;
+  }
   // Try to register the subchannel before setting the subchannel pool.
   // Otherwise, in case of a registration race, unreffing c in
   // RegisterSubchannel() will cause c to be tried to be unregistered, while
@@ -612,10 +628,8 @@ void Subchannel::WatchConnectivityState(
     grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
   }
   work_serializer_.Run(
-      [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
-        auto* watcher_ptr = watcher.get();
-        watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                               status);
+      [watcher, state = state_, status = status_]() {
+        watcher->OnConnectivityStateChange(state, status);
       },
       DEBUG_LOCATION);
   watcher_list_.AddWatcherLocked(std::move(watcher));
@@ -704,12 +718,15 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
   }
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_cpp_string(absl::StrCat(
-            "Subchannel connectivity state changed to ",
-            ConnectivityStateName(state),
-            status.ok() ? "" : absl::StrCat(": ", status_.ToString()))));
+    if (status.ok()) {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << "Subchannel connectivity state changed to "
+          << ConnectivityStateName(state);
+    } else {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << "Subchannel connectivity state changed to "
+          << ConnectivityStateName(state) << ": " << status;
+    }
   }
   // Notify watchers.
   watcher_list_.NotifyLocked(state, status_);
@@ -769,10 +786,15 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
         next_attempt_time_ - Timestamp::Now();
     GRPC_TRACE_LOG(subchannel, INFO)
         << "subchannel " << this << " " << key_.ToString()
-        << ": connect failed (" << StatusToString(error)
-        << "), backing off for " << time_until_next_attempt.millis() << " ms";
+        << ": connect failed (" << StatusToString(error) << ")"
+        << (created_from_endpoint_
+                ? ", no retry will be attempted (created from endpoint); "
+                  "remaining in TRANSIENT_FAILURE"
+                : ", backing off for " +
+                      std::to_string(time_until_next_attempt.millis()) + " ms");
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
+    if (created_from_endpoint_) return;
     retry_timer_handle_ = event_engine_->RunAfter(
         time_until_next_attempt,
         [self = WeakRef(DEBUG_LOCATION, "RetryTimer")]() mutable {
@@ -792,7 +814,7 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
 }
 
 bool Subchannel::PublishTransportLocked() {
-  auto socket_node = std::move(connecting_result_.socket_node);
+  auto socket_node = connecting_result_.transport->GetSocketNode();
   if (connecting_result_.transport->filter_stack_transport() != nullptr) {
     // Construct channel stack.
     // Builder takes ownership of transport.

data/src/core/client_channel/subchannel.h

@@ -58,6 +58,11 @@
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/work_serializer.h"
 
+/** This arg is intended for internal use only, primarily
+ *  for passing endpoint information during subchannel creation or connection.
+ */
+#define GRPC_ARG_SUBCHANNEL_ENDPOINT "grpc.internal.subchannel_endpoint"
+
 namespace grpc_core {
 
 class SubchannelCall;
@@ -168,14 +173,8 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     // Invoked whenever the subchannel's connectivity state changes.
     // There will be only one invocation of this method on a given watcher
     // instance at any given time.
-    // A ref to the watcher is passed in here so that the implementation
-    // can unref it in the appropriate synchronization context (e.g.,
-    // inside a WorkSerializer).
-    // TODO(roth): Figure out a cleaner way to guarantee that the ref is
-    // released in the right context.
-    virtual void OnConnectivityStateChange(
-        RefCountedPtr<ConnectivityStateWatcherInterface> self,
-        grpc_connectivity_state state, const absl::Status& status) = 0;
+    virtual void OnConnectivityStateChange(grpc_connectivity_state state,
+                                           const absl::Status& status) = 0;
 
     virtual grpc_pollset_set* interested_parties() = 0;
   };
@@ -334,6 +333,9 @@ class Subchannel final : public DualRefCounted<Subchannel> {
   RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
   // Subchannel key that identifies this subchannel in the subchannel pool.
   const SubchannelKey key_;
+  // boolean value that identifies this subchannel is created from event engine
+  // endpoint.
+  const bool created_from_endpoint_;
   // Actual address to connect to.  May be different than the address in
   // key_ if overridden by proxy mapper.
   grpc_resolved_address address_for_connect_;

data/src/core/client_channel/subchannel_pool_interface.cc

@@ -38,13 +38,12 @@ SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
                              const ChannelArgs& args)
     : address_(address), args_(args) {}
 
-bool SubchannelKey::operator<(const SubchannelKey& other) const {
-  if (address_.len < other.address_.len) return true;
-  if (address_.len > other.address_.len) return false;
+int SubchannelKey::Compare(const SubchannelKey& other) const {
+  if (address_.len < other.address_.len) return -1;
+  if (address_.len > other.address_.len) return 1;
   int r = memcmp(address_.addr, other.address_.addr, address_.len);
-  if (r < 0) return true;
-  if (r > 0) return false;
-  return args_ < other.args();
+  if (r != 0) return r;
+  return QsortCompare(args_, other.args_);
 }
 
 std::string SubchannelKey::ToString() const {

data/src/core/client_channel/subchannel_pool_interface.h

@@ -45,7 +45,17 @@ class SubchannelKey final {
   SubchannelKey(SubchannelKey&& other) noexcept = default;
   SubchannelKey& operator=(SubchannelKey&& other) noexcept = default;
 
-  bool operator<(const SubchannelKey& other) const;
+  bool operator<(const SubchannelKey& other) const {
+    return Compare(other) < 0;
+  }
+  bool operator>(const SubchannelKey& other) const {
+    return Compare(other) > 0;
+  }
+  bool operator==(const SubchannelKey& other) const {
+    return Compare(other) == 0;
+  }
+
+  int Compare(const SubchannelKey& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
   const ChannelArgs& args() const { return args_; }

data/src/core/config/config_vars.cc

@@ -30,7 +30,9 @@
 #endif  // !GPR_DEFAULT_LOG_VERBOSITY_STRING
 
 #ifdef GRPC_ENABLE_FORK_SUPPORT
+#ifndef GRPC_ENABLE_FORK_SUPPORT_DEFAULT
 #define GRPC_ENABLE_FORK_SUPPORT_DEFAULT true
+#endif  // !defined(GRPC_ENABLE_FORK_SUPPORT_DEFAULT)
 #else
 #define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
 #endif  // GRPC_ENABLE_FORK_SUPPORT
@@ -76,6 +78,11 @@ ABSL_FLAG(absl::optional<bool>, grpc_cpp_experimental_disable_reflection, {},
           "EXPERIMENTAL. Only respected when there is a dependency on "
           ":grpc++_reflection. If true, no reflection server will be "
           "automatically added.");
+ABSL_FLAG(
+    absl::optional<int32_t>, grpc_channelz_max_orphaned_nodes, {},
+    "EXPERIMENTAL: If non-zero, extend the lifetime of channelz nodes past the "
+    "underlying object lifetime, up to this many nodes. The value may be "
+    "adjusted slightly to account for implementation limits.");
 
 namespace grpc_core {
 
@@ -84,6 +91,10 @@ ConfigVars::ConfigVars(const Overrides& overrides)
           LoadConfig(FLAGS_grpc_client_channel_backup_poll_interval_ms,
                      "GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS",
                      overrides.client_channel_backup_poll_interval_ms, 5000)),
+      channelz_max_orphaned_nodes_(
+          LoadConfig(FLAGS_grpc_channelz_max_orphaned_nodes,
+                     "GRPC_CHANNELZ_MAX_ORPHANED_NODES",
+                     overrides.channelz_max_orphaned_nodes, 0)),
       enable_fork_support_(LoadConfig(
           FLAGS_grpc_enable_fork_support, "GRPC_ENABLE_FORK_SUPPORT",
           overrides.enable_fork_support, GRPC_ENABLE_FORK_SUPPORT_DEFAULT)),
@@ -146,7 +157,8 @@ std::string ConfigVars::ToString() const {
       ", not_use_system_ssl_roots: ", NotUseSystemSslRoots() ? "true" : "false",
       ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"",
       ", cpp_experimental_disable_reflection: ",
-      CppExperimentalDisableReflection() ? "true" : "false");
+      CppExperimentalDisableReflection() ? "true" : "false",
+      ", channelz_max_orphaned_nodes: ", ChannelzMaxOrphanedNodes());
 }
 
 }  // namespace grpc_core

data/src/core/config/config_vars.h

@@ -35,6 +35,7 @@ class GPR_DLL ConfigVars {
  public:
   struct Overrides {
     absl::optional<int32_t> client_channel_backup_poll_interval_ms;
+    absl::optional<int32_t> channelz_max_orphaned_nodes;
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
@@ -104,12 +105,19 @@ class GPR_DLL ConfigVars {
   bool CppExperimentalDisableReflection() const {
     return cpp_experimental_disable_reflection_;
   }
+  // EXPERIMENTAL: If non-zero, extend the lifetime of channelz nodes past the
+  // underlying object lifetime, up to this many nodes. The value may be
+  // adjusted slightly to account for implementation limits.
+  int32_t ChannelzMaxOrphanedNodes() const {
+    return channelz_max_orphaned_nodes_;
+  }
 
  private:
   explicit ConfigVars(const Overrides& overrides);
   static const ConfigVars& Load();
   static std::atomic<ConfigVars*> config_vars_;
   int32_t client_channel_backup_poll_interval_ms_;
+  int32_t channelz_max_orphaned_nodes_;
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;

data/src/core/config/core_configuration.cc

@@ -25,8 +25,10 @@
 namespace grpc_core {
 
 std::atomic<CoreConfiguration*> CoreConfiguration::config_{nullptr};
-std::atomic<CoreConfiguration::RegisteredBuilder*> CoreConfiguration::builders_{
-    nullptr};
+std::atomic<CoreConfiguration::RegisteredBuilder*>
+    CoreConfiguration::builders_[static_cast<size_t>(BuilderScope::kCount)]{
+        nullptr, nullptr};
+std::atomic<bool> CoreConfiguration::has_config_ever_been_produced_{false};
 void (*CoreConfiguration::default_builder_)(CoreConfiguration::Builder*);
 
 CoreConfiguration::Builder::Builder() = default;
@@ -41,23 +43,37 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
       channel_init_(builder->channel_init_.Build()),
       handshaker_registry_(builder->handshaker_registry_.Build()),
       channel_creds_registry_(builder->channel_creds_registry_.Build()),
+      call_creds_registry_(builder->call_creds_registry_.Build()),
       service_config_parser_(builder->service_config_parser_.Build()),
       resolver_registry_(builder->resolver_registry_.Build()),
       lb_policy_registry_(builder->lb_policy_registry_.Build()),
       proxy_mapper_registry_(builder->proxy_mapper_registry_.Build()),
       certificate_provider_registry_(
-          builder->certificate_provider_registry_.Build()) {}
+          builder->certificate_provider_registry_.Build()),
+      endpoint_transport_registry_(
+          builder->endpoint_transport_registry_.Build()) {}
 
 void CoreConfiguration::RegisterBuilder(
-    absl::AnyInvocable<void(Builder*)> builder) {
+    BuilderScope scope, absl::AnyInvocable<void(Builder*)> builder,
+    SourceLocation whence) {
   CHECK(config_.load(std::memory_order_relaxed) == nullptr)
       << "CoreConfiguration was already instantiated before builder "
          "registration was completed";
+  if (scope == BuilderScope::kPersistent) {
+    CHECK(!has_config_ever_been_produced_.load(std::memory_order_relaxed))
+        << "Persistent builders cannot be registered after the first "
+           "CoreConfiguration has been produced";
+  }
+  CHECK_NE(scope, BuilderScope::kCount);
+  auto& head = builders_[static_cast<size_t>(scope)];
   RegisteredBuilder* n = new RegisteredBuilder();
+  VLOG(4) << "Registering " << scope << " builder from " << whence.file() << ":"
+          << whence.line();
   n->builder = std::move(builder);
-  n->next = builders_.load(std::memory_order_relaxed);
-  while (!builders_.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
-                                          std::memory_order_relaxed)) {
+  n->whence = whence;
+  n->next = head.load(std::memory_order_relaxed);
+  while (!head.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
+                                     std::memory_order_relaxed)) {
   }
   CHECK(config_.load(std::memory_order_relaxed) == nullptr)
       << "CoreConfiguration was already instantiated before builder "
@@ -65,6 +81,7 @@ void CoreConfiguration::RegisterBuilder(
 }
 
 const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
+  has_config_ever_been_produced_.store(true, std::memory_order_relaxed);
   // Construct builder, pass it up to code that knows about build configuration
   Builder builder;
   // The linked list of builders stores things in reverse registration order.
@@ -72,13 +89,21 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
   // actually need to run things in forward registration order, so we iterate
   // once over the linked list to build a vector of builders, and then iterate
   // over said vector in reverse to actually run the builders.
+  // Note that we also iterate scopes in reverse order here too, so that when
+  // we run the builders in the reverse generated order we'll actually run
+  // persistent builders before ephemeral ones.
   std::vector<RegisteredBuilder*> registered_builders;
-  for (RegisteredBuilder* b = builders_.load(std::memory_order_acquire);
-       b != nullptr; b = b->next) {
-    registered_builders.push_back(b);
+  for (auto scope : {BuilderScope::kEphemeral, BuilderScope::kPersistent}) {
+    for (RegisteredBuilder* b = builders_[static_cast<size_t>(scope)].load(
+             std::memory_order_acquire);
+         b != nullptr; b = b->next) {
+      registered_builders.push_back(b);
+    }
   }
   for (auto it = registered_builders.rbegin(); it != registered_builders.rend();
        ++it) {
+    VLOG(4) << "Running builder from " << (*it)->whence.file() << ":"
+            << (*it)->whence.line();
     (*it)->builder(&builder);
   }
   // Finally, call the built in configuration builder.
@@ -100,12 +125,27 @@ const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {
 void CoreConfiguration::Reset() {
   delete config_.exchange(nullptr, std::memory_order_acquire);
   RegisteredBuilder* builder =
-      builders_.exchange(nullptr, std::memory_order_acquire);
+      builders_[static_cast<size_t>(BuilderScope::kEphemeral)].exchange(
+          nullptr, std::memory_order_acquire);
+  while (builder != nullptr) {
+    RegisteredBuilder* next = builder->next;
+    delete builder;
+    builder = next;
+  }
+}
+
+void CoreConfiguration::
+    ResetEverythingIncludingPersistentBuildersAbsolutelyNotRecommended() {
+  has_config_ever_been_produced_.store(false, std::memory_order_relaxed);
+  RegisteredBuilder* builder =
+      builders_[static_cast<size_t>(BuilderScope::kPersistent)].exchange(
+          nullptr, std::memory_order_acquire);
   while (builder != nullptr) {
     RegisteredBuilder* next = builder->next;
     delete builder;
     builder = next;
   }
+  Reset();
 }
 
 }  // namespace grpc_core

data/src/core/config/core_configuration.h

@@ -16,11 +16,13 @@
 #define GRPC_SRC_CORE_CONFIG_CORE_CONFIGURATION_H
 
 #include <grpc/support/port_platform.h>
+#include <sys/stat.h>
 
 #include <atomic>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
 #include "src/core/credentials/transport/tls/certificate_provider_registry.h"
 #include "src/core/handshaker/handshaker_registry.h"
@@ -30,6 +32,8 @@
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/transport/endpoint_transport.h"
+#include "src/core/util/debug_location.h"
 
 namespace grpc_core {
 
@@ -40,6 +44,27 @@ class GRPC_DLL CoreConfiguration {
   CoreConfiguration(const CoreConfiguration&) = delete;
   CoreConfiguration& operator=(const CoreConfiguration&) = delete;
 
+  // BulderScope is used to indicate whether a builder is persistent - these
+  // are builders that are used every time the configuration is built, or
+  // ephemeral - each time the configuration is built these are thrown away.
+  //
+  // Considerations for choosing persistent vs ephemeral:
+  // - For testing we want ephemeral builders, so the next test can throw away
+  //   configuration.
+  // - For adapting gRPC to different environments we typically want persistent
+  //   builders.
+  //   - However, if the adaption should run only once per process, then
+  //     ephemeral is better.
+  //
+  // Builders are instantiated in scope order - persistent first, ephemeral
+  // second.
+  enum class BuilderScope {
+    kPersistent,
+    kEphemeral,
+    // Must be last, do not use as a scope.
+    kCount,
+  };
+
   // Builder is passed to plugins, etc... at initialization time to collect
   // their configuration and assemble the published CoreConfiguration.
   class Builder {
@@ -58,6 +83,10 @@ class GRPC_DLL CoreConfiguration {
       return &channel_creds_registry_;
     }
 
+    CallCredsRegistry<>::Builder* call_creds_registry() {
+      return &call_creds_registry_;
+    }
+
     ServiceConfigParser::Builder* service_config_parser() {
       return &service_config_parser_;
     }
@@ -78,6 +107,10 @@ class GRPC_DLL CoreConfiguration {
       return &certificate_provider_registry_;
     }
 
+    EndpointTransportRegistry::Builder* endpoint_transport_registry() {
+      return &endpoint_transport_registry_;
+    }
+
    private:
     friend class CoreConfiguration;
 
@@ -85,11 +118,13 @@ class GRPC_DLL CoreConfiguration {
     ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
     ChannelCredsRegistry<>::Builder channel_creds_registry_;
+    CallCredsRegistry<>::Builder call_creds_registry_;
     ServiceConfigParser::Builder service_config_parser_;
     ResolverRegistry::Builder resolver_registry_;
     LoadBalancingPolicyRegistry::Builder lb_policy_registry_;
     ProxyMapperRegistry::Builder proxy_mapper_registry_;
     CertificateProviderRegistry::Builder certificate_provider_registry_;
+    EndpointTransportRegistry::Builder endpoint_transport_registry_;
 
     Builder();
     CoreConfiguration* Build();
@@ -99,6 +134,7 @@ class GRPC_DLL CoreConfiguration {
   struct RegisteredBuilder {
     absl::AnyInvocable<void(Builder*)> builder;
     RegisteredBuilder* next;
+    SourceLocation whence;
   };
 
   // Temporarily replaces core configuration with what is built from the
@@ -121,8 +157,10 @@ class GRPC_DLL CoreConfiguration {
       // Backup current core configuration and replace/reset.
       config_restore_ =
           CoreConfiguration::config_.exchange(p, std::memory_order_acquire);
-      builders_restore_ = CoreConfiguration::builders_.exchange(
-          nullptr, std::memory_order_acquire);
+      builders_restore_ =
+          CoreConfiguration::builders_[static_cast<size_t>(
+                                           BuilderScope::kEphemeral)]
+              .exchange(nullptr, std::memory_order_acquire);
     }
 
     ~WithSubstituteBuilder() {
@@ -130,8 +168,10 @@ class GRPC_DLL CoreConfiguration {
       Reset();
       CHECK(CoreConfiguration::config_.exchange(
                 config_restore_, std::memory_order_acquire) == nullptr);
-      CHECK(CoreConfiguration::builders_.exchange(
-                builders_restore_, std::memory_order_acquire) == nullptr);
+      CHECK(CoreConfiguration::builders_[static_cast<size_t>(
+                                             BuilderScope::kEphemeral)]
+                .exchange(builders_restore_, std::memory_order_acquire) ==
+            nullptr);
     }
 
    private:
@@ -153,13 +193,34 @@ class GRPC_DLL CoreConfiguration {
   // Attach a registration function globally.
   // Each registration function is called *in addition to*
   // BuildCoreConfiguration for the default core configuration.
-  static void RegisterBuilder(absl::AnyInvocable<void(Builder*)> builder);
+  static void RegisterBuilder(BuilderScope scope,
+                              absl::AnyInvocable<void(Builder*)> builder,
+                              SourceLocation whence);
+
+  static void RegisterPersistentBuilder(
+      absl::AnyInvocable<void(Builder*)> builder, SourceLocation whence = {}) {
+    RegisterBuilder(BuilderScope::kPersistent, std::move(builder), whence);
+  }
+
+  static void RegisterEphemeralBuilder(
+      absl::AnyInvocable<void(Builder*)> builder, SourceLocation whence = {}) {
+    RegisterBuilder(BuilderScope::kEphemeral, std::move(builder), whence);
+  }
 
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.
-  // Clears any dynamically registered builders.
+  // Clears any dynamically registered ephemeral builders.
   static void Reset();
 
+  // Reset, but also reset persistent builders. This is not recommended, but
+  // is useful for tests that assume exactly the default open source
+  // configuration when running in other environments.
+  //
+  // TODO(ctiller, roth, yashkt): Remove the need for this method, and then
+  // move the legacy plugin registration mechanism to be a persistent builder.
+  static void
+  ResetEverythingIncludingPersistentBuildersAbsolutelyNotRecommended();
+
   // Helper for tests: Reset the configuration, build a special one, run some
   // code, and then reset the configuration again.
   // Templatized to be sure no codegen in normal builds.
@@ -186,6 +247,10 @@ class GRPC_DLL CoreConfiguration {
     return channel_creds_registry_;
   }
 
+  const CallCredsRegistry<>& call_creds_registry() const {
+    return call_creds_registry_;
+  }
+
   const ServiceConfigParser& service_config_parser() const {
     return service_config_parser_;
   }
@@ -206,6 +271,10 @@ class GRPC_DLL CoreConfiguration {
     return certificate_provider_registry_;
   }
 
+  const EndpointTransportRegistry& endpoint_transport_registry() const {
+    return endpoint_transport_registry_;
+  }
+
   static void SetDefaultBuilder(void (*builder)(CoreConfiguration::Builder*)) {
     default_builder_ = builder;
   }
@@ -219,8 +288,13 @@ class GRPC_DLL CoreConfiguration {
 
   // The configuration
   static std::atomic<CoreConfiguration*> config_;
+  // Has a configuration *ever* been produced - we verify this is false for
+  // persistent builders so that we can prove consistency build to build for
+  // these.
+  static std::atomic<bool> has_config_ever_been_produced_;
   // Extra registered builders
-  static std::atomic<RegisteredBuilder*> builders_;
+  static std::atomic<RegisteredBuilder*>
+      builders_[static_cast<size_t>(BuilderScope::kCount)];
   // Default builder
   static void (*default_builder_)(CoreConfiguration::Builder*);
 
@@ -228,13 +302,32 @@ class GRPC_DLL CoreConfiguration {
   ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
   ChannelCredsRegistry<> channel_creds_registry_;
+  CallCredsRegistry<> call_creds_registry_;
   ServiceConfigParser service_config_parser_;
   ResolverRegistry resolver_registry_;
   LoadBalancingPolicyRegistry lb_policy_registry_;
   ProxyMapperRegistry proxy_mapper_registry_;
   CertificateProviderRegistry certificate_provider_registry_;
+  EndpointTransportRegistry endpoint_transport_registry_;
 };
 
+template <typename Sink>
+void AbslStringify(Sink& sink, CoreConfiguration::BuilderScope scope) {
+  switch (scope) {
+    case CoreConfiguration::BuilderScope::kPersistent:
+      sink.Append("Persistent");
+      break;
+    case CoreConfiguration::BuilderScope::kEphemeral:
+      sink.Append("Ephemeral");
+      break;
+    case CoreConfiguration::BuilderScope::kCount:
+      sink.Append("Count(");
+      sink.Append(std::to_string(static_cast<size_t>(scope)));
+      sink.Append(")");
+      break;
+  }
+}
+
 extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core