grpc 1.71.0 → 1.74.0

data/src/core/client_channel/subchannel.cc

@@ -35,6 +35,7 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/interception_chain.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -57,7 +58,6 @@
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
@@ -244,13 +244,12 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
-      callstk,              // call_stack
-      nullptr,              // server_transport_data
-      args.path.c_slice(),  // path
-      args.start_time,      // start_time
-      args.deadline,        // deadline
-      args.arena,           // arena
-      args.call_combiner    // call_combiner
+      callstk,            // call_stack
+      nullptr,            // server_transport_data
+      args.start_time,    // start_time
+      args.deadline,      // deadline
+      args.arena,         // arena
+      args.call_combiner  // call_combiner
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
@@ -423,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();
       }
     }
@@ -453,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);
     });
   }
 }
@@ -512,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)),
@@ -549,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();
@@ -579,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
@@ -613,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));
@@ -705,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_);
@@ -770,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 {
@@ -793,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

@@ -29,6 +29,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -44,7 +45,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.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;
@@ -95,7 +100,6 @@ class SubchannelCall final {
   struct Args {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     grpc_polling_entity* pollent;
-    Slice path;
     gpr_cycle_counter start_time;
     Timestamp deadline;
     Arena* arena;
@@ -169,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;
   };
@@ -335,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/client_channel/subchannel_stream_client.cc

@@ -130,7 +130,7 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   const Duration timeout = retry_backoff_.NextAttemptDelay();
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
     LOG(INFO) << tracer_ << " " << this
-              << ": SubchannelStreamClient health check call lost...";
+              << ": SubchannelStreamClient call lost...";
     if (timeout > Duration::Zero()) {
       LOG(INFO) << tracer_ << " " << this << ": ... will retry in "
                 << timeout.millis() << "ms.";
@@ -139,10 +139,10 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
     }
   }
   retry_timer_handle_ = event_engine_->RunAfter(
-      timeout, [self = Ref(DEBUG_LOCATION, "health_retry_timer")]() mutable {
+      timeout, [self = Ref(DEBUG_LOCATION, "retry_timer")]() mutable {
         ExecCtx exec_ctx;
         self->OnRetryTimer();
-        self.reset(DEBUG_LOCATION, "health_retry_timer");
+        self.reset(DEBUG_LOCATION, "retry_timer");
       });
 }
 
@@ -152,7 +152,7 @@ void SubchannelStreamClient::OnRetryTimer() {
       call_state_ == nullptr) {
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
       LOG(INFO) << tracer_ << " " << this
-                << ": SubchannelStreamClient restarting health check call";
+                << ": SubchannelStreamClient restarting call";
     }
     StartCallLocked();
   }
@@ -164,9 +164,9 @@ void SubchannelStreamClient::OnRetryTimer() {
 //
 
 SubchannelStreamClient::CallState::CallState(
-    RefCountedPtr<SubchannelStreamClient> health_check_client,
+    RefCountedPtr<SubchannelStreamClient> subchannel_stream_client,
     grpc_pollset_set* interested_parties)
-    : subchannel_stream_client_(std::move(health_check_client)),
+    : subchannel_stream_client_(std::move(subchannel_stream_client)),
       pollent_(grpc_polling_entity_create_from_pollset_set(interested_parties)),
       arena_(subchannel_stream_client_->call_allocator_->MakeArena()) {}
 
@@ -192,7 +192,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   SubchannelCall::Args args = {
       subchannel_stream_client_->connected_subchannel_,
       &pollent_,
-      Slice::FromStaticString("/grpc.health.v1.Health/Watch"),
       gpr_get_cycle_counter(),  // start_time
       Timestamp::InfFuture(),   // deadline
       arena_.get(),
@@ -299,7 +298,7 @@ void SubchannelStreamClient::CallState::AfterCallStackDestruction(
 void SubchannelStreamClient::CallState::OnCancelComplete(
     void* arg, grpc_error_handle /*error*/) {
   auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
-  GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "health_cancel");
+  GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "cancel_batch");
   self->call_->Unref(DEBUG_LOCATION, "cancel");
 }
 
@@ -322,7 +321,7 @@ void SubchannelStreamClient::CallState::Cancel() {
     GRPC_CALL_COMBINER_START(
         &call_combiner_,
         GRPC_CLOSURE_CREATE(StartCancel, this, grpc_schedule_on_exec_ctx),
-        absl::OkStatus(), "health_cancel");
+        absl::OkStatus(), "cancel_batch");
   }
 }
 
@@ -406,18 +405,22 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
     LOG(INFO) << self->subchannel_stream_client_->tracer_ << " "
               << self->subchannel_stream_client_.get()
               << ": SubchannelStreamClient CallState " << self
-              << ": health watch failed with status " << status;
+              << ": call failed with status " << status;
   }
   // Clean up.
   self->recv_trailing_metadata_.Clear();
   // Report call end.
+  // Note: We hold a ref to the SubchannelStreamClient here to ensure
+  // that it lives long enough for us to release the mutex, since the
+  // call to CallEndedLocked() may release the last ref.
+  auto subchannel_stream_client = self->subchannel_stream_client_->Ref();
   MutexLock lock(&self->subchannel_stream_client_->mu_);
   if (self->subchannel_stream_client_->event_handler_ != nullptr) {
     self->subchannel_stream_client_->event_handler_
         ->RecvTrailingMetadataReadyLocked(self->subchannel_stream_client_.get(),
                                           status);
   }
-  // For status UNIMPLEMENTED, give up and assume always healthy.
+  // For status UNIMPLEMENTED, give up.
   self->CallEndedLocked(/*retry=*/status != GRPC_STATUS_UNIMPLEMENTED);
 }
 

data/src/core/client_channel/subchannel_stream_client.h

@@ -30,6 +30,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -40,7 +41,6 @@
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/orphanable.h"
@@ -202,7 +202,7 @@ class SubchannelStreamClient final
   Mutex mu_;
   std::unique_ptr<CallEventHandler> event_handler_ ABSL_GUARDED_BY(mu_);
 
-  // The data associated with the current health check call.  It holds a ref
+  // The data associated with the current call.  It holds a ref
   // to this SubchannelStreamClient object.
   OrphanablePtr<CallState> call_state_ ABSL_GUARDED_BY(mu_);
 

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