grpc 1.71.0 → 1.75.0

data/src/core/client_channel/retry_interceptor.h

@@ -15,22 +15,22 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_INTERCEPTOR_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_INTERCEPTOR_H
 
+#include "src/core/call/interception_chain.h"
 #include "src/core/call/request_buffer.h"
 #include "src/core/client_channel/client_channel_args.h"
 #include "src/core/client_channel/retry_service_config.h"
 #include "src/core/client_channel/retry_throttle.h"
 #include "src/core/filter/filter_args.h"
-#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/util/backoff.h"
 
 namespace grpc_core {
 
 namespace retry_detail {
+
 class RetryState {
  public:
-  RetryState(
-      const internal::RetryMethodConfig* retry_policy,
-      RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data);
+  RetryState(const internal::RetryMethodConfig* retry_policy,
+             RefCountedPtr<internal::RetryThrottler> retry_throttler);
 
   // if nullopt --> commit & don't retry
   // if duration --> retry after duration
@@ -41,36 +41,37 @@ class RetryState {
 
   template <typename Sink>
   friend void AbslStringify(Sink& sink, const RetryState& state) {
-    sink.Append(absl::StrCat(
-        "policy:{",
-        state.retry_policy_ != nullptr ? absl::StrCat(*state.retry_policy_)
-                                       : "none",
-        "} throttle:", state.retry_throttle_data_ != nullptr,
-        " attempts:", state.num_attempts_completed_));
+    sink.Append(absl::StrCat("policy:{",
+                             state.retry_policy_ != nullptr
+                                 ? absl::StrCat(*state.retry_policy_)
+                                 : "none",
+                             "} throttler:", state.retry_throttler_ != nullptr,
+                             " attempts:", state.num_attempts_completed_));
   }
 
  private:
   const internal::RetryMethodConfig* const retry_policy_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   int num_attempts_completed_ = 0;
   BackOff retry_backoff_;
 };
 
-absl::StatusOr<RefCountedPtr<internal::ServerRetryThrottleData>>
-ServerRetryThrottleDataFromChannelArgs(const ChannelArgs& args);
 }  // namespace retry_detail
 
 class RetryInterceptor : public Interceptor {
  public:
-  RetryInterceptor(
-      const ChannelArgs& args,
-      RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data);
+  RetryInterceptor(const ChannelArgs& args,
+                   RefCountedPtr<internal::RetryThrottler> retry_throttler);
 
   static absl::StatusOr<RefCountedPtr<RetryInterceptor>> Create(
-      const ChannelArgs& args, const FilterArgs&);
+      const ChannelArgs& args, const FilterArgs& filter_args);
 
   void Orphaned() override {}
 
+  static void UpdateBlackboard(const ServiceConfig& service_config,
+                               const Blackboard* old_blackboard,
+                               Blackboard* new_blackboard);
+
  protected:
   void InterceptCall(UnstartedCallHandler unstarted_call_handler) override;
 
@@ -149,7 +150,7 @@ class RetryInterceptor : public Interceptor {
 
   const size_t per_rpc_retry_buffer_size_;
   const size_t service_config_parser_index_;
-  const RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  const RefCountedPtr<internal::RetryThrottler> retry_throttler_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/retry_service_config.cc

@@ -30,9 +30,9 @@
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/util/json/json_channel_args.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.

data/src/core/client_channel/retry_service_config.h

@@ -25,9 +25,9 @@
 #include <optional>
 
 #include "absl/strings/string_view.h"
+#include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/service_config/service_config_parser.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"

data/src/core/client_channel/retry_throttle.cc

@@ -18,14 +18,9 @@
 
 #include "src/core/client_channel/retry_throttle.h"
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <cstdint>
 #include <limits>
-#include <map>
-#include <string>
-#include <utility>
 
 #include "src/core/util/useful.h"
 
@@ -33,6 +28,7 @@ namespace grpc_core {
 namespace internal {
 
 namespace {
+
 template <typename T>
 T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
   T prev_value = value.load(std::memory_order_relaxed);
@@ -43,60 +39,74 @@ T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
                                         std::memory_order_relaxed));
   return new_value;
 }
+
 }  // namespace
 
 //
-// ServerRetryThrottleData
+// RetryThrottler
 //
 
-ServerRetryThrottleData::ServerRetryThrottleData(
+RefCountedPtr<RetryThrottler> RetryThrottler::Create(
     uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
-    ServerRetryThrottleData* old_throttle_data)
-    : max_milli_tokens_(max_milli_tokens),
-      milli_token_ratio_(milli_token_ratio) {
+    RefCountedPtr<RetryThrottler> previous) {
+  if (previous != nullptr && previous->max_milli_tokens_ == max_milli_tokens &&
+      previous->milli_token_ratio_ == milli_token_ratio) {
+    return previous;
+  }
+  // previous is null or has different parameters.  Create a new one.
   uintptr_t initial_milli_tokens = max_milli_tokens;
   // If there was a pre-existing entry for this server name, initialize
   // the token count by scaling proportionately to the old data.  This
   // ensures that if we're already throttling retries on the old scale,
   // we will start out doing the same thing on the new one.
-  if (old_throttle_data != nullptr) {
-    double token_fraction =
-        static_cast<double>(
-            old_throttle_data->milli_tokens_.load(std::memory_order_relaxed)) /
-        static_cast<double>(old_throttle_data->max_milli_tokens_);
+  if (previous != nullptr) {
+    double token_fraction = static_cast<double>(previous->milli_tokens_) /
+                            static_cast<double>(previous->max_milli_tokens_);
     initial_milli_tokens =
         static_cast<uintptr_t>(token_fraction * max_milli_tokens);
   }
-  milli_tokens_.store(initial_milli_tokens, std::memory_order_relaxed);
-  // If there was a pre-existing entry, mark it as stale and give it a
-  // pointer to the new entry, which is its replacement.
-  if (old_throttle_data != nullptr) {
-    Ref().release();  // Ref held by pre-existing entry.
-    old_throttle_data->replacement_.store(this, std::memory_order_release);
-  }
+  auto throttle_data = MakeRefCounted<RetryThrottler>(
+      max_milli_tokens, milli_token_ratio, initial_milli_tokens);
+  if (previous != nullptr) previous->SetReplacement(throttle_data);
+  return throttle_data;
+}
+
+UniqueTypeName RetryThrottler::Type() {
+  static UniqueTypeName::Factory factory("retry_throttle");
+  return factory.Create();
 }
 
-ServerRetryThrottleData::~ServerRetryThrottleData() {
-  ServerRetryThrottleData* replacement =
-      replacement_.load(std::memory_order_acquire);
+RetryThrottler::RetryThrottler(uintptr_t max_milli_tokens,
+                               uintptr_t milli_token_ratio,
+                               uintptr_t milli_tokens)
+    : max_milli_tokens_(max_milli_tokens),
+      milli_token_ratio_(milli_token_ratio),
+      milli_tokens_(milli_tokens) {}
+
+RetryThrottler::~RetryThrottler() {
+  RetryThrottler* replacement = replacement_.load(std::memory_order_acquire);
   if (replacement != nullptr) {
     replacement->Unref();
   }
 }
 
-void ServerRetryThrottleData::GetReplacementThrottleDataIfNeeded(
-    ServerRetryThrottleData** throttle_data) {
+void RetryThrottler::SetReplacement(RefCountedPtr<RetryThrottler> replacement) {
+  replacement_.store(replacement.release(), std::memory_order_release);
+}
+
+void RetryThrottler::GetReplacementThrottleDataIfNeeded(
+    RetryThrottler** throttle_data) {
   while (true) {
-    ServerRetryThrottleData* new_throttle_data =
+    RetryThrottler* new_throttle_data =
         (*throttle_data)->replacement_.load(std::memory_order_acquire);
     if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
 }
 
-bool ServerRetryThrottleData::RecordFailure() {
+bool RetryThrottler::RecordFailure() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We decrement milli_tokens by 1000 (1 token) for each failure.
   const uintptr_t new_value = ClampedAdd<intptr_t>(
@@ -108,9 +118,9 @@ bool ServerRetryThrottleData::RecordFailure() {
   return new_value > throttle_data->max_milli_tokens_ / 2;
 }
 
-void ServerRetryThrottleData::RecordSuccess() {
+void RetryThrottler::RecordSuccess() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We increment milli_tokens by milli_token_ratio for each success.
   ClampedAdd<intptr_t>(
@@ -120,34 +130,5 @@ void ServerRetryThrottleData::RecordSuccess() {
                                  std::numeric_limits<intptr_t>::max())));
 }
 
-//
-// ServerRetryThrottleMap
-//
-
-ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
-  static ServerRetryThrottleMap* m = new ServerRetryThrottleMap();
-  return m;
-}
-
-RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const std::string& server_name, uintptr_t max_milli_tokens,
-    uintptr_t milli_token_ratio) {
-  MutexLock lock(&mu_);
-  auto it = map_.find(server_name);
-  ServerRetryThrottleData* throttle_data =
-      it == map_.end() ? nullptr : it->second.get();
-  if (throttle_data == nullptr ||
-      throttle_data->max_milli_tokens() != max_milli_tokens ||
-      throttle_data->milli_token_ratio() != milli_token_ratio) {
-    // Entry not found, or found with old parameters.  Create a new one.
-    it = map_.emplace(server_name,
-                      MakeRefCounted<ServerRetryThrottleData>(
-                          max_milli_tokens, milli_token_ratio, throttle_data))
-             .first;
-    throttle_data = it->second.get();
-  }
-  return throttle_data->Ref();
-}
-
 }  // namespace internal
 }  // namespace grpc_core

data/src/core/client_channel/retry_throttle.h

@@ -19,29 +19,29 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <atomic>
-#include <map>
-#include <string>
 
-#include "absl/base/thread_annotations.h"
-#include "src/core/util/ref_counted.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 namespace internal {
 
 /// Tracks retry throttling data for an individual server name.
-class ServerRetryThrottleData final
-    : public RefCounted<ServerRetryThrottleData> {
+class RetryThrottler final : public Blackboard::Entry {
  public:
-  ServerRetryThrottleData(uintptr_t max_milli_tokens,
-                          uintptr_t milli_token_ratio,
-                          ServerRetryThrottleData* old_throttle_data);
-  ~ServerRetryThrottleData() override;
+  static RefCountedPtr<RetryThrottler> Create(
+      uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+      RefCountedPtr<RetryThrottler> previous);
+
+  static UniqueTypeName Type();
+
+  // Do not instantiate directly -- use Create() instead.
+  RetryThrottler(uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+                 uintptr_t milli_tokens);
+  ~RetryThrottler() override;
 
   /// Records a failure.  Returns true if it's okay to send a retry.
   bool RecordFailure();
@@ -49,39 +49,25 @@ class ServerRetryThrottleData final
   /// Records a success.
   void RecordSuccess();
 
+  // Exposed for testing purposes only.
   uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
   uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
+  intptr_t milli_tokens() const {
+    return milli_tokens_.load(std::memory_order_relaxed);
+  }
 
  private:
-  void GetReplacementThrottleDataIfNeeded(
-      ServerRetryThrottleData** throttle_data);
+  void SetReplacement(RefCountedPtr<RetryThrottler> replacement);
+
+  void GetReplacementThrottleDataIfNeeded(RetryThrottler** throttle_data);
 
   const uintptr_t max_milli_tokens_;
   const uintptr_t milli_token_ratio_;
   std::atomic<intptr_t> milli_tokens_;
-  // A pointer to the replacement for this ServerRetryThrottleData entry.
+  // A pointer to the replacement for this RetryThrottler entry.
   // If non-nullptr, then this entry is stale and must not be used.
   // We hold a reference to the replacement.
-  std::atomic<ServerRetryThrottleData*> replacement_{nullptr};
-};
-
-/// Global map of server name to retry throttle data.
-class ServerRetryThrottleMap final {
- public:
-  static ServerRetryThrottleMap* Get();
-
-  /// Returns the failure data for \a server_name, creating a new entry if
-  /// needed.
-  RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const std::string& server_name, uintptr_t max_milli_tokens,
-      uintptr_t milli_token_ratio);
-
- private:
-  using StringToDataMap =
-      std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
-
-  Mutex mu_;
-  StringToDataMap map_ ABSL_GUARDED_BY(mu_);
+  std::atomic<RetryThrottler*> replacement_{nullptr};
 };
 
 }  // namespace internal

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"
@@ -117,7 +117,7 @@ class LegacyConnectedSubchannel : public ConnectedSubchannel {
     channel_stack_.reset(DEBUG_LOCATION, "ConnectedSubchannel");
   }
 
-  channelz::SubchannelNode* channelz_node() const {
+  channelz::SubchannelNode* channelz_node() const override {
     return channelz_node_.get();
   }
 
@@ -220,6 +220,8 @@ class NewConnectedSubchannel : public ConnectedSubchannel {
     Crash("legacy ping method called in call v3 impl");
   }
 
+  channelz::SubchannelNode* channelz_node() const override { return nullptr; }
+
  private:
   RefCountedPtr<UnstartedCallDestination> call_destination_;
   RefCountedPtr<TransportCallDestination> transport_;
@@ -244,13 +246,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);
@@ -411,23 +412,37 @@ class Subchannel::ConnectedSubchannelStateWatcher final
       // we will see TRANSIENT_FAILURE followed by SHUTDOWN, but if not, we
       // will see only SHUTDOWN.  Either way, we react to the first one we
       // see, ignoring anything that happens after that.
-      if (c->connected_subchannel_ == nullptr) return;
       if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
           new_state == GRPC_CHANNEL_SHUTDOWN) {
+        RefCountedPtr<ConnectedSubchannel> connected_subchannel =
+            std::move(c->connected_subchannel_);
+        if (connected_subchannel == nullptr) return;
         GRPC_TRACE_LOG(subchannel, INFO)
             << "subchannel " << c << " " << c->key_.ToString()
-            << ": Connected subchannel " << c->connected_subchannel_.get()
+            << ": Connected subchannel " << connected_subchannel.get()
             << " reports " << ConnectivityStateName(new_state) << ": "
             << status;
-        c->connected_subchannel_.reset();
         if (c->channelz_node() != nullptr) {
-          c->channelz_node()->SetChildSocket(nullptr);
+          if (connected_subchannel->channelz_node() != nullptr) {
+            connected_subchannel->channelz_node()->RemoveParent(
+                c->channelz_node());
+          }
         }
-        // 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 +468,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 +525,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 +563,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 +591,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 +634,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 +724,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 +792,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 +820,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.
@@ -859,7 +886,9 @@ bool Subchannel::PublishTransportLocked() {
       << "subchannel " << this << " " << key_.ToString()
       << ": new connected subchannel at " << connected_subchannel_.get();
   if (channelz_node_ != nullptr) {
-    channelz_node_->SetChildSocket(std::move(socket_node));
+    if (socket_node != nullptr) {
+      socket_node->AddParent(channelz_node_.get());
+    }
   }
   // Start watching connected subchannel.
   connected_subchannel_->StartWatch(