grpc 1.81.1 → 1.85.0

data/src/core/client_channel/subchannel.cc

@@ -34,6 +34,7 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/buffered_call.h"
 #include "src/core/client_channel/client_channel_internal.h"
+#include "src/core/client_channel/subchannel_metrics.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/client_channel/subchannel_stream_limiter.h"
 #include "src/core/config/core_configuration.h"
@@ -57,6 +58,7 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
@@ -97,972 +99,56 @@ using ::grpc_event_engine::experimental::EventEngine;
 // Subchannel::ConnectivityStateWatcherInterface.
 using TransportConnectivityStateWatcher = ConnectivityStateWatcherInterface;
 
-//
-// Subchannel::Call
-//
-
-RefCountedPtr<Subchannel::Call> Subchannel::Call::Ref() {
-  IncrementRefCount();
-  return RefCountedPtr<Subchannel::Call>(this);
-}
-
-RefCountedPtr<Subchannel::Call> Subchannel::Call::Ref(
-    const DebugLocation& location, const char* reason) {
-  IncrementRefCount(location, reason);
-  return RefCountedPtr<Subchannel::Call>(this);
-}
-
-//
-// Subchannel
-//
-
-RefCountedPtr<Subchannel> Subchannel::Create(
-    OrphanablePtr<SubchannelConnector> connector,
-    const grpc_resolved_address& address, const ChannelArgs& args) {
-  if (!IsSubchannelConnectionScalingEnabled()) {
-    return OldSubchannel::Create(std::move(connector), address, args);
-  }
-  return NewSubchannel::Create(std::move(connector), address, args);
-}
-
-Subchannel::Subchannel()
-    : DualRefCounted<Subchannel>(GRPC_TRACE_FLAG_ENABLED(subchannel_refcount)
-                                     ? "Subchannel"
-                                     : nullptr) {}
-
-ChannelArgs Subchannel::MakeSubchannelArgs(
-    const ChannelArgs& channel_args, const ChannelArgs& address_args,
-    const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
-    const std::string& channel_default_authority) {
-  // Note that we start with the channel-level args and then apply the
-  // per-address args, so that if a value is present in both, the one
-  // in the channel-level args is used.  This is particularly important
-  // for the GRPC_ARG_DEFAULT_AUTHORITY arg, which we want to allow
-  // resolvers to set on a per-address basis only if the application
-  // did not explicitly set it at the channel level.
-  return channel_args.UnionWith(address_args)
-      .SetObject(subchannel_pool)
-      // If we haven't already set the default authority arg (i.e., it
-      // was not explicitly set by the application nor overridden by
-      // the resolver), add it from the channel's default.
-      .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, channel_default_authority)
-      // Remove channel args that should not affect subchannel
-      // uniqueness.
-      .Remove(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME)
-      .Remove(GRPC_ARG_INHIBIT_HEALTH_CHECKING)
-      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
-      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP)
-      .Remove(GRPC_ARG_CHANNELZ_CHANNEL_NODE)
-      // Remove all keys with the no-subchannel prefix.
-      .RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX);
-}
-
-//
-// OldSubchannel::ConnectedSubchannel
-//
-
-class OldSubchannel::ConnectedSubchannel
-    : public RefCounted<ConnectedSubchannel> {
- public:
-  const ChannelArgs& args() const { return args_; }
-
-  virtual void StartWatch(
-      grpc_pollset_set* interested_parties,
-      OrphanablePtr<TransportConnectivityStateWatcher> watcher) = 0;
-
-  // Methods for v3 stack.
-  virtual void Ping(absl::AnyInvocable<void(absl::Status)> on_ack) = 0;
-  virtual RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
-      const = 0;
-
-  // Methods for legacy stack.
-  virtual RefCountedPtr<Call> CreateCall(CreateCallArgs args,
-                                         grpc_error_handle* error) = 0;
-  virtual void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) = 0;
-
- protected:
-  explicit ConnectedSubchannel(const ChannelArgs& args)
-      : RefCounted<ConnectedSubchannel>(
-            GRPC_TRACE_FLAG_ENABLED(subchannel_refcount) ? "ConnectedSubchannel"
-                                                         : nullptr),
-        args_(args) {}
-
- private:
-  ChannelArgs args_;
-};
-
-//
-// OldSubchannel::LegacyConnectedSubchannel
-//
-
-class OldSubchannel::LegacyConnectedSubchannel final
-    : public ConnectedSubchannel {
- public:
-  LegacyConnectedSubchannel(
-      RefCountedPtr<grpc_channel_stack> channel_stack, const ChannelArgs& args,
-      RefCountedPtr<channelz::SubchannelNode> channelz_node)
-      : ConnectedSubchannel(args),
-        channelz_node_(std::move(channelz_node)),
-        channel_stack_(std::move(channel_stack)) {}
-
-  ~LegacyConnectedSubchannel() override {
-    channel_stack_.reset(DEBUG_LOCATION, "ConnectedSubchannel");
-  }
-
-  void StartWatch(
-      grpc_pollset_set* interested_parties,
-      OrphanablePtr<TransportConnectivityStateWatcher> watcher) override {
-    grpc_transport_op* op = grpc_make_transport_op(nullptr);
-    op->start_connectivity_watch = std::move(watcher);
-    op->start_connectivity_watch_state = GRPC_CHANNEL_READY;
-    op->bind_pollset_set = interested_parties;
-    grpc_channel_element* elem =
-        grpc_channel_stack_element(channel_stack_.get(), 0);
-    elem->filter->start_transport_op(elem, op);
-  }
-
-  void Ping(absl::AnyInvocable<void(absl::Status)>) override {
-    Crash("call v3 ping method called in legacy impl");
-  }
-
-  RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
-      const override {
-    Crash("call v3 unstarted_call_destination method called in legacy impl");
-  }
-
-  RefCountedPtr<Call> CreateCall(CreateCallArgs args,
-                                 grpc_error_handle* error) override {
-    const size_t allocation_size =
-        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)) +
-        channel_stack_->call_stack_size;
-    Arena* arena = args.arena;
-    return RefCountedPtr<SubchannelCall>(
-        new (arena->Alloc(allocation_size)) SubchannelCall(
-            RefAsSubclass<LegacyConnectedSubchannel>(), args, error));
-  }
-
-  void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) override {
-    grpc_transport_op* op = grpc_make_transport_op(nullptr);
-    op->send_ping.on_initiate = on_initiate;
-    op->send_ping.on_ack = on_ack;
-    grpc_channel_element* elem =
-        grpc_channel_stack_element(channel_stack_.get(), 0);
-    elem->filter->start_transport_op(elem, op);
-  }
-
- private:
-  class SubchannelCall final : public Call {
-   public:
-    SubchannelCall(
-        RefCountedPtr<LegacyConnectedSubchannel> connected_subchannel,
-        CreateCallArgs args, grpc_error_handle* error);
-
-    void StartTransportStreamOpBatch(
-        grpc_transport_stream_op_batch* batch) override;
-
-    void SetAfterCallStackDestroy(grpc_closure* closure) override;
-
-    // When refcount drops to 0, destroys itself and the associated call stack,
-    // but does NOT free the memory because it's in the call arena.
-    void Unref() override;
-    void Unref(const DebugLocation& location, const char* reason) override;
-
-   private:
-    // If channelz is enabled, intercepts recv_trailing so that we may check the
-    // status and associate it to a subchannel.
-    void MaybeInterceptRecvTrailingMetadata(
-        grpc_transport_stream_op_batch* batch);
-
-    static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
-
-    // Interface of RefCounted<>.
-    void IncrementRefCount() override;
-    void IncrementRefCount(const DebugLocation& location,
-                           const char* reason) override;
-
-    static void Destroy(void* arg, grpc_error_handle error);
-
-    RefCountedPtr<LegacyConnectedSubchannel> connected_subchannel_;
-    grpc_closure* after_call_stack_destroy_ = nullptr;
-    // State needed to support channelz interception of recv trailing metadata.
-    grpc_closure recv_trailing_metadata_ready_;
-    grpc_closure* original_recv_trailing_metadata_ = nullptr;
-    grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
-    Timestamp deadline_;
-  };
-
-  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
-  RefCountedPtr<grpc_channel_stack> channel_stack_;
-};
-
-//
-// OldSubchannel::LegacyConnectedSubchannel::SubchannelCall
-//
-
-OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::SubchannelCall(
-    RefCountedPtr<LegacyConnectedSubchannel> connected_subchannel,
-    CreateCallArgs args, grpc_error_handle* error)
-    : connected_subchannel_(std::move(connected_subchannel)),
-      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.start_time,    // start_time
-      args.deadline,      // deadline
-      args.arena,         // arena
-      args.call_combiner  // call_combiner
-  };
-  *error = grpc_call_stack_init(connected_subchannel_->channel_stack_.get(), 1,
-                                SubchannelCall::Destroy, this, &call_args);
-  if (GPR_UNLIKELY(!error->ok())) {
-    LOG(ERROR) << "error: " << StatusToString(*error);
-    return;
-  }
-  grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
-  if (connected_subchannel_->channelz_node_ != nullptr) {
-    connected_subchannel_->channelz_node_->RecordCallStarted();
-  }
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch) {
-  MaybeInterceptRecvTrailingMetadata(batch);
-  grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(this);
-  grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
-  GRPC_TRACE_LOG(channel, INFO)
-      << "OP[" << top_elem->filter->name << ":" << top_elem
-      << "]: " << grpc_transport_stream_op_batch_string(batch, false);
-  top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    SetAfterCallStackDestroy(grpc_closure* closure) {
-  GRPC_CHECK_EQ(after_call_stack_destroy_, nullptr);
-  GRPC_CHECK_NE(closure, nullptr);
-  after_call_stack_destroy_ = closure;
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::Unref() {
-  GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::Unref(
-    const DebugLocation& /*location*/, const char* reason) {
-  GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::Destroy(
-    void* arg, grpc_error_handle /*error*/) {
-  SubchannelCall* self = static_cast<SubchannelCall*>(arg);
-  // Keep some members before destroying the subchannel call.
-  grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel =
-      std::move(self->connected_subchannel_);
-  // Destroy the subchannel call.
-  self->~SubchannelCall();
-  // Destroy the call stack. This should be after destroying the subchannel
-  // call, because call->after_call_stack_destroy(), if not null, will free
-  // the call arena.
-  grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(self), nullptr,
-                          after_call_stack_destroy);
-  // Automatically reset connected_subchannel. This should be after destroying
-  // the call stack, because destroying call stack needs access to the channel
-  // stack.
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    MaybeInterceptRecvTrailingMetadata(grpc_transport_stream_op_batch* batch) {
-  // only intercept payloads with recv trailing.
-  if (!batch->recv_trailing_metadata) return;
-  // only add interceptor is channelz is enabled.
-  if (connected_subchannel_->channelz_node_ == nullptr) return;
-  GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
-                    this, grpc_schedule_on_exec_ctx);
-  // save some state needed for the interception callback.
-  GRPC_CHECK_EQ(recv_trailing_metadata_, nullptr);
-  recv_trailing_metadata_ =
-      batch->payload->recv_trailing_metadata.recv_trailing_metadata;
-  original_recv_trailing_metadata_ =
-      batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-  batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-      &recv_trailing_metadata_ready_;
-}
-
-namespace {
-
-// Sets *status based on the rest of the parameters.
-void GetCallStatus(grpc_status_code* status, Timestamp deadline,
-                   grpc_metadata_batch* md_batch, grpc_error_handle error) {
-  if (!error.ok()) {
-    grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
-  } else {
-    *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
-  }
-}
-
-}  // namespace
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    RecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
-  SubchannelCall* call = static_cast<SubchannelCall*>(arg);
-  GRPC_CHECK_NE(call->recv_trailing_metadata_, nullptr);
-  grpc_status_code status = GRPC_STATUS_OK;
-  GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_, error);
-  channelz::SubchannelNode* channelz_node =
-      call->connected_subchannel_->channelz_node_.get();
-  GRPC_CHECK_NE(channelz_node, nullptr);
-  if (status == GRPC_STATUS_OK) {
-    channelz_node->RecordCallSucceeded();
-  } else {
-    channelz_node->RecordCallFailed();
-  }
-  Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_, error);
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    IncrementRefCount() {
-  GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
-}
-
-void OldSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    IncrementRefCount(const DebugLocation& /*location*/, const char* reason) {
-  GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
-}
-
-//
-// OldSubchannel::NewConnectedSubchannel
-//
-
-class OldSubchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
- public:
-  class TransportCallDestination final : public CallDestination {
-   public:
-    explicit TransportCallDestination(OrphanablePtr<ClientTransport> transport)
-        : transport_(std::move(transport)) {}
-
-    ClientTransport* transport() { return transport_.get(); }
-
-    void HandleCall(CallHandler handler) override {
-      transport_->StartCall(std::move(handler));
-    }
-
-    void Orphaned() override { transport_.reset(); }
-
-   private:
-    OrphanablePtr<ClientTransport> transport_;
-  };
-
-  NewConnectedSubchannel(
-      RefCountedPtr<UnstartedCallDestination> call_destination,
-      RefCountedPtr<TransportCallDestination> transport,
-      const ChannelArgs& args)
-      : ConnectedSubchannel(args),
-        call_destination_(std::move(call_destination)),
-        transport_(std::move(transport)) {}
-
-  void StartWatch(
-      grpc_pollset_set*,
-      OrphanablePtr<TransportConnectivityStateWatcher> watcher) override {
-    transport_->transport()->StartConnectivityWatch(std::move(watcher));
-  }
-
-  void Ping(absl::AnyInvocable<void(absl::Status)>) override {
-    // TODO(ctiller): add new transport API for this in v3 stack
-    Crash("not implemented");
-  }
-
-  RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
-      const override {
-    return call_destination_;
-  }
-
-  RefCountedPtr<Call> CreateCall(CreateCallArgs, grpc_error_handle*) override {
-    Crash("legacy CreateCall() called on v3 impl");
-  }
-
-  void Ping(grpc_closure*, grpc_closure*) override {
-    Crash("legacy ping method called in call v3 impl");
-  }
-
- private:
-  RefCountedPtr<UnstartedCallDestination> call_destination_;
-  RefCountedPtr<TransportCallDestination> transport_;
-};
-
-//
-// OldSubchannel::ConnectedSubchannelStateWatcher
-//
-
-class OldSubchannel::ConnectedSubchannelStateWatcher final
-    : public AsyncConnectivityStateWatcherInterface {
- public:
-  // Must be instantiated while holding c->mu.
-  explicit ConnectedSubchannelStateWatcher(WeakRefCountedPtr<OldSubchannel> c)
-      : subchannel_(std::move(c)) {}
-
-  ~ConnectedSubchannelStateWatcher() override {
-    subchannel_.reset(DEBUG_LOCATION, "state_watcher");
-  }
-
- private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state,
-                                 const absl::Status& status) override {
-    OldSubchannel* c = subchannel_.get();
-    {
-      MutexLock lock(&c->mu_);
-      // If we're either shutting down or have already seen this connection
-      // failure (i.e., c->connected_subchannel_ is null), do nothing.
-      //
-      // The transport reports TRANSIENT_FAILURE upon GOAWAY but SHUTDOWN
-      // upon connection close.  So if the server gracefully shuts down,
-      // 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 (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 " << connected_subchannel.get()
-            << " reports " << ConnectivityStateName(new_state) << ": "
-            << 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();
-      }
-    }
-  }
-
-  WeakRefCountedPtr<OldSubchannel> subchannel_;
-};
-
-//
-// OldSubchannel::ConnectivityStateWatcherList
-//
-
-void OldSubchannel::ConnectivityStateWatcherList::AddWatcherLocked(
-    RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  watchers_.insert(std::move(watcher));
-}
-
-void OldSubchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
-    ConnectivityStateWatcherInterface* watcher) {
-  watchers_.erase(watcher);
-}
-
-void OldSubchannel::ConnectivityStateWatcherList::NotifyLocked(
-    grpc_connectivity_state state, const absl::Status& status) {
-  for (const auto& watcher : watchers_) {
-    subchannel_->work_serializer_.Run([watcher, state, status]() {
-      watcher->OnConnectivityStateChange(state, status);
-    });
-  }
-}
-
-void OldSubchannel::ConnectivityStateWatcherList::NotifyOnKeepaliveUpdateLocked(
-    Duration new_keepalive_time) {
-  for (const auto& watcher : watchers_) {
-    subchannel_->work_serializer_.Run([watcher, new_keepalive_time]() {
-      watcher->OnKeepaliveUpdate(new_keepalive_time);
-    });
-  }
-}
-
-uint32_t
-OldSubchannel::ConnectivityStateWatcherList::GetMaxConnectionsPerSubchannel()
-    const {
-  uint32_t max_connections_per_subchannel = 1;
-  for (const auto& watcher : watchers_) {
-    max_connections_per_subchannel =
-        std::max(max_connections_per_subchannel,
-                 watcher->max_connections_per_subchannel());
-  }
-  return max_connections_per_subchannel;
-}
-
-//
-// OldSubchannel
-//
-
-namespace {
-
-BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
-                                           Duration* min_connect_timeout) {
-  const std::optional<Duration> fixed_reconnect_backoff =
-      args.GetDurationFromIntMillis("grpc.testing.fixed_reconnect_backoff_ms");
-  if (fixed_reconnect_backoff.has_value()) {
-    const Duration backoff =
-        std::max(Duration::Milliseconds(100), *fixed_reconnect_backoff);
-    *min_connect_timeout = backoff;
-    return BackOff::Options()
-        .set_initial_backoff(backoff)
-        .set_multiplier(1.0)
-        .set_jitter(0.0)
-        .set_max_backoff(backoff);
-  }
-  const Duration initial_backoff = std::max(
-      Duration::Milliseconds(100),
-      args.GetDurationFromIntMillis(GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)
-          .value_or(Duration::Seconds(
-              GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS)));
-  *min_connect_timeout =
-      std::max(Duration::Milliseconds(100),
-               args.GetDurationFromIntMillis(GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)
-                   .value_or(Duration::Seconds(
-                       GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS)));
-  const Duration max_backoff =
-      std::max(Duration::Milliseconds(100),
-               args.GetDurationFromIntMillis(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)
-                   .value_or(Duration::Seconds(
-                       GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS)));
-  return BackOff::Options()
-      .set_initial_backoff(initial_backoff)
-      .set_multiplier(GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
-      .set_jitter(GRPC_SUBCHANNEL_RECONNECT_JITTER)
-      .set_max_backoff(max_backoff);
-}
-
-}  // namespace
-
-OldSubchannel::OldSubchannel(SubchannelKey key,
-                             OrphanablePtr<SubchannelConnector> connector,
-                             const ChannelArgs& args)
-    : 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)),
-      watcher_list_(this),
-      work_serializer_(args_.GetObjectRef<EventEngine>()),
-      backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)),
-      event_engine_(args_.GetObjectRef<EventEngine>()) {
-  // A grpc_init is added here to ensure that grpc_shutdown does not happen
-  // until the subchannel is destroyed. Subchannels can persist longer than
-  // channels because they maybe reused/shared among multiple channels. As a
-  // result the subchannel destruction happens asynchronously to channel
-  // destruction. If the last channel destruction triggers a grpc_shutdown
-  // before the last subchannel destruction, then there maybe race conditions
-  // triggering segmentation faults. To prevent this issue, we call a
-  // grpc_init here and a grpc_shutdown in the subchannel destructor.
-  InitInternally();
-  global_stats().IncrementClientSubchannelsCreated();
-  GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
-                    grpc_schedule_on_exec_ctx);
-  // Check proxy mapper to determine address to connect to and channel
-  // args to use.
-  address_for_connect_ = CoreConfiguration::Get()
-                             .proxy_mapper_registry()
-                             .MapAddress(key_.address(), &args_)
-                             .value_or(key_.address());
-  // Initialize channelz.
-  const bool channelz_enabled = args_.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
-                                    .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT);
-  if (channelz_enabled) {
-    const size_t channel_tracer_max_memory = Clamp(
-        args_.GetInt(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE)
-            .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT),
-        0, INT_MAX);
-    channelz_node_ = MakeRefCounted<channelz::SubchannelNode>(
-        grpc_sockaddr_to_uri(&key_.address())
-            .value_or("<unknown address type>"),
-        channel_tracer_max_memory);
-    GRPC_CHANNELZ_LOG(channelz_node_) << "subchannel created";
-    channelz_node_->SetChannelArgs(args_);
-    args_ = args_.SetObject<channelz::BaseNode>(channelz_node_);
-  }
-}
-
-OldSubchannel::~OldSubchannel() {
-  if (channelz_node_ != nullptr) {
-    GRPC_CHANNELZ_LOG(channelz_node_) << "Subchannel destroyed";
-    channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
-  }
-  connector_.reset();
-  grpc_pollset_set_destroy(pollset_set_);
-  // grpc_shutdown is called here because grpc_init is called in the ctor.
-  ShutdownInternally();
-}
-
-RefCountedPtr<Subchannel> OldSubchannel::Create(
-    OrphanablePtr<SubchannelConnector> connector,
-    const grpc_resolved_address& address, const ChannelArgs& args) {
-  SubchannelKey key(address, args);
-  auto* subchannel_pool = args.GetObject<SubchannelPoolInterface>();
-  GRPC_CHECK_NE(subchannel_pool, nullptr);
-  RefCountedPtr<OldSubchannel> c =
-      subchannel_pool->FindSubchannel(key).TakeAsSubclass<OldSubchannel>();
-  if (c != nullptr) {
-    return c;
-  }
-  c = MakeRefCounted<OldSubchannel>(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
-  // its key maps to a different subchannel.
-  RefCountedPtr<OldSubchannel> registered =
-      subchannel_pool->RegisterSubchannel(c->key_, c)
-          .TakeAsSubclass<OldSubchannel>();
-  if (registered == c) c->subchannel_pool_ = subchannel_pool->Ref();
-  return registered;
-}
-
-void OldSubchannel::ThrottleKeepaliveTime(Duration new_keepalive_time) {
-  MutexLock lock(&mu_);
-  ThrottleKeepaliveTimeLocked(new_keepalive_time);
-}
-
-void OldSubchannel::ThrottleKeepaliveTimeLocked(Duration new_keepalive_time) {
-  // Only update the value if the new keepalive time is larger.
-  if (new_keepalive_time > keepalive_time_) {
-    keepalive_time_ = new_keepalive_time;
-    GRPC_TRACE_LOG(subchannel, INFO)
-        << "subchannel " << this << " " << key_.ToString()
-        << ": throttling keepalive time to " << new_keepalive_time;
-    args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time.millis());
-  }
-}
-
-channelz::SubchannelNode* OldSubchannel::channelz_node() {
-  return channelz_node_.get();
-}
-
-void OldSubchannel::WatchConnectivityState(
-    RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  MutexLock lock(&mu_);
-  grpc_pollset_set* interested_parties = watcher->interested_parties();
-  if (interested_parties != nullptr) {
-    grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
-  }
-  work_serializer_.Run(
-      [watcher, state = state_, status = status_]() {
-        watcher->OnConnectivityStateChange(state, status);
-      },
-      DEBUG_LOCATION);
-  watcher_list_.AddWatcherLocked(std::move(watcher));
-}
-
-void OldSubchannel::CancelConnectivityStateWatch(
-    ConnectivityStateWatcherInterface* watcher) {
-  MutexLock lock(&mu_);
-  grpc_pollset_set* interested_parties = watcher->interested_parties();
-  if (interested_parties != nullptr) {
-    grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
-  }
-  watcher_list_.RemoveWatcherLocked(watcher);
-}
-
-void OldSubchannel::RequestConnection() {
-  MutexLock lock(&mu_);
-  if (state_ == GRPC_CHANNEL_IDLE) {
-    StartConnectingLocked();
-  }
-}
-
-void OldSubchannel::ResetBackoff() {
-  // Hold a ref to ensure cancellation and subsequent deletion of the closure
-  // does not eliminate the last ref and destroy the Subchannel before the
-  // method returns.
-  auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  MutexLock lock(&mu_);
-  backoff_.Reset();
-  if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      event_engine_->Cancel(retry_timer_handle_)) {
-    OnRetryTimerLocked();
-  } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-    next_attempt_time_ = Timestamp::Now();
-  }
-}
-
-void OldSubchannel::Orphaned() {
-  // The subchannel_pool is only used once here in this subchannel, so the
-  // access can be outside of the lock.
-  if (subchannel_pool_ != nullptr) {
-    subchannel_pool_->UnregisterSubchannel(key_, this);
-    subchannel_pool_.reset();
-  }
-  MutexLock lock(&mu_);
-  GRPC_CHECK(!shutdown_);
-  shutdown_ = true;
-  connector_.reset();
-  connected_subchannel_.reset();
-}
-
-void OldSubchannel::GetOrAddDataProducer(
-    UniqueTypeName type,
-    std::function<void(DataProducerInterface**)> get_or_add) {
-  MutexLock lock(&mu_);
-  auto it = data_producer_map_.emplace(type, nullptr).first;
-  get_or_add(&it->second);
-}
-
-void OldSubchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
-  MutexLock lock(&mu_);
-  auto it = data_producer_map_.find(data_producer->type());
-  if (it != data_producer_map_.end() && it->second == data_producer) {
-    data_producer_map_.erase(it);
-  }
-}
-
-// Note: Must be called with a state that is different from the current state.
-void OldSubchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
-                                               const absl::Status& status) {
-  state_ = state;
-  if (status.ok()) {
-    status_ = status;
-  } else {
-    // Augment status message to include IP address.
-    status_ = absl::Status(status.code(),
-                           absl::StrCat(grpc_sockaddr_to_uri(&key_.address())
-                                            .value_or("<unknown address type>"),
-                                        ": ", status.message()));
-    status.ForEachPayload(
-        [this](absl::string_view key, const absl::Cord& value)
-        // Want to use ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_) here,
-        // but that won't work, because we can't pass the lock
-        // annotation through absl::Status::ForEachPayload().
-        ABSL_NO_THREAD_SAFETY_ANALYSIS { status_.SetPayload(key, value); });
-  }
-  if (channelz_node_ != nullptr) {
-    channelz_node_->UpdateConnectivityState(state);
-    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_);
-}
-
-void OldSubchannel::OnRetryTimer() {
-  MutexLock lock(&mu_);
-  OnRetryTimerLocked();
-}
-
-void OldSubchannel::OnRetryTimerLocked() {
-  if (shutdown_) return;
-  GRPC_TRACE_LOG(subchannel, INFO)
-      << "subchannel " << this << " " << key_.ToString()
-      << ": backoff delay elapsed, reporting IDLE";
-  SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, absl::OkStatus());
-}
-
-void OldSubchannel::StartConnectingLocked() {
-  // Set next attempt time.
-  const Timestamp now = Timestamp::Now();
-  const Timestamp min_deadline = now + min_connect_timeout_;
-  next_attempt_time_ = now + backoff_.NextAttemptDelay();
-  // Report CONNECTING.
-  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::OkStatus());
-  // Start connection attempt.
-  SubchannelConnector::Args args;
-  args.address = &address_for_connect_;
-  args.interested_parties = pollset_set_;
-  args.deadline = std::max(next_attempt_time_, min_deadline);
-  args.channel_args = args_;
-  WeakRef(DEBUG_LOCATION, "Connect").release();  // Ref held by callback.
-  connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
-}
-
-void OldSubchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
-  WeakRefCountedPtr<OldSubchannel> c(static_cast<OldSubchannel*>(arg));
-  {
-    MutexLock lock(&c->mu_);
-    c->OnConnectingFinishedLocked(error);
-  }
-  c.reset(DEBUG_LOCATION, "Connect");
-}
+namespace {
 
-void OldSubchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
-  if (shutdown_) {
-    connecting_result_.Reset();
-    return;
-  }
-  // If we didn't get a transport or we fail to publish it, report
-  // TRANSIENT_FAILURE and start the retry timer.
-  // Note that if the connection attempt took longer than the backoff
-  // time, then the timer will fire immediately, and we will quickly
-  // transition back to IDLE.
-  if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
-    const Duration time_until_next_attempt =
-        next_attempt_time_ - Timestamp::Now();
-    GRPC_TRACE_LOG(subchannel, INFO)
-        << "subchannel " << this << " " << key_.ToString()
-        << ": 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")
-                    .TakeAsSubclass<OldSubchannel>()]() mutable {
-          {
-            ExecCtx exec_ctx;
-            self->OnRetryTimer();
-            // Subchannel deletion might require an active ExecCtx. So if
-            // self.reset() is not called here, the WeakRefCountedPtr
-            // destructor may run after the ExecCtx declared in the callback
-            // is destroyed. Since subchannel may get destroyed when the
-            // WeakRefCountedPtr destructor runs, it may not have an active
-            // ExecCtx - thus leading to crashes.
-            self.reset();
-          }
-        });
-  }
-}
-
-bool OldSubchannel::PublishTransportLocked() {
-  auto socket_node = connecting_result_.transport->GetSocketNode();
-  if (connecting_result_.transport->filter_stack_transport() != nullptr) {
-    // Construct channel stack.
-    // Builder takes ownership of transport.
-    ChannelStackBuilderImpl builder(
-        "subchannel", GRPC_CLIENT_SUBCHANNEL,
-        connecting_result_.channel_args.SetObject(
-            std::exchange(connecting_result_.transport, nullptr)));
-    if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
-      return false;
-    }
-    absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stack = builder.Build();
-    if (!stack.ok()) {
-      connecting_result_.Reset();
-      LOG(ERROR) << "subchannel " << this << " " << key_.ToString()
-                 << ": error initializing subchannel stack: " << stack.status();
-      return false;
-    }
-    connected_subchannel_ = MakeRefCounted<LegacyConnectedSubchannel>(
-        std::move(*stack), args_, channelz_node_);
-  } else {
-    OrphanablePtr<ClientTransport> transport(
-        std::exchange(connecting_result_.transport, nullptr)
-            ->client_transport());
-    InterceptionChainBuilder builder(
-        connecting_result_.channel_args.SetObject(transport.get()));
-    if (channelz_node_ != nullptr) {
-      // TODO(ctiller): If/when we have a good way to access the subchannel
-      // from a filter (maybe GetContext<Subchannel>?), consider replacing
-      // these two hooks with a filter so that we can avoid storing two
-      // separate refs to the channelz node in each connection.
-      builder.AddOnClientInitialMetadata(
-          [channelz_node = channelz_node_](ClientMetadata&) {
-            channelz_node->RecordCallStarted();
-          });
-      builder.AddOnServerTrailingMetadata(
-          [channelz_node = channelz_node_](ServerMetadata& metadata) {
-            if (IsStatusOk(metadata)) {
-              channelz_node->RecordCallSucceeded();
-            } else {
-              channelz_node->RecordCallFailed();
-            }
-          });
-    }
-    CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
-        GRPC_CLIENT_SUBCHANNEL, builder);
-    auto transport_destination =
-        MakeRefCounted<NewConnectedSubchannel::TransportCallDestination>(
-            std::move(transport));
-    auto call_destination = builder.Build(transport_destination);
-    if (!call_destination.ok()) {
-      connecting_result_.Reset();
-      LOG(ERROR) << "subchannel " << this << " " << key_.ToString()
-                 << ": error initializing subchannel stack: "
-                 << call_destination.status();
-      return false;
-    }
-    connected_subchannel_ = MakeRefCounted<NewConnectedSubchannel>(
-        std::move(*call_destination), std::move(transport_destination), args_);
-  }
-  connecting_result_.Reset();
-  // Publish.
-  GRPC_TRACE_LOG(subchannel, INFO)
-      << "subchannel " << this << " " << key_.ToString()
-      << ": new connected subchannel at " << connected_subchannel_.get();
-  if (channelz_node_ != nullptr) {
-    if (socket_node != nullptr) {
-      socket_node->AddParent(channelz_node_.get());
+constexpr absl::string_view kSecurityLevelUnknown = "unknown";
+constexpr absl::string_view kSecurityLevelNone = "none";
+constexpr absl::string_view kSecurityLevelIntegrityOnly = "integrity_only";
+constexpr absl::string_view kSecurityLevelPrivacyAndIntegrity =
+    "privacy_and_integrity";
+
+absl::string_view GetSecurityLevelFromArgs(const ChannelArgs& args) {
+  auto auth_context = args.GetObject<grpc_auth_context>();
+  if (auth_context != nullptr) {
+    grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
+        auth_context, GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
+    const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
+    if (prop != nullptr) {
+      absl::string_view tsi_level(prop->value, prop->value_length);
+      if (tsi_level == "TSI_SECURITY_NONE") {
+        return kSecurityLevelNone;
+      } else if (tsi_level == "TSI_INTEGRITY_ONLY") {
+        return kSecurityLevelIntegrityOnly;
+      } else if (tsi_level == "TSI_PRIVACY_AND_INTEGRITY") {
+        return kSecurityLevelPrivacyAndIntegrity;
+      }
     }
   }
-  connected_subchannel_->StartWatch(
-      pollset_set_, MakeOrphanable<ConnectedSubchannelStateWatcher>(
-                        WeakRef(DEBUG_LOCATION, "state_watcher")
-                            .TakeAsSubclass<OldSubchannel>()));
-  // Report initial state.
-  SetConnectivityStateLocked(GRPC_CHANNEL_READY, absl::Status());
-  return true;
-}
-
-RefCountedPtr<Subchannel::Call> OldSubchannel::CreateCall(
-    CreateCallArgs args, grpc_error_handle* error) {
-  auto connected_subchannel = GetConnectedSubchannel();
-  if (connected_subchannel == nullptr) return nullptr;
-  return connected_subchannel->CreateCall(args, error);
+  return kSecurityLevelUnknown;
 }
 
-RefCountedPtr<UnstartedCallDestination> OldSubchannel::call_destination() {
-  auto connected_subchannel = GetConnectedSubchannel();
-  if (connected_subchannel == nullptr) return nullptr;
-  return connected_subchannel->unstarted_call_destination();
-}
+}  // namespace
 
-void OldSubchannel::Ping(absl::AnyInvocable<void(absl::Status)>) {
-  // TODO(ctiller): Implement
-}
+//
+// Subchannel::Call
+//
 
-absl::Status OldSubchannel::Ping(grpc_closure* on_initiate,
-                                 grpc_closure* on_ack) {
-  auto connected_subchannel = GetConnectedSubchannel();
-  if (connected_subchannel == nullptr) {
-    return absl::UnavailableError("no connection");
-  }
-  connected_subchannel->Ping(on_initiate, on_ack);
-  return absl::OkStatus();
+RefCountedPtr<Subchannel::Call> Subchannel::Call::Ref() {
+  IncrementRefCount();
+  return RefCountedPtr<Subchannel::Call>(this);
 }
 
-RefCountedPtr<OldSubchannel::ConnectedSubchannel>
-OldSubchannel::GetConnectedSubchannel() {
-  MutexLock lock(&mu_);
-  return connected_subchannel_;
+RefCountedPtr<Subchannel::Call> Subchannel::Call::Ref(
+    const DebugLocation& location, const char* reason) {
+  IncrementRefCount(location, reason);
+  return RefCountedPtr<Subchannel::Call>(this);
 }
 
 //
-// NewSubchannel::ConnectedSubchannel
+// Subchannel::ConnectedSubchannel
 //
 
-class NewSubchannel::ConnectedSubchannel
+class Subchannel::ConnectedSubchannel
     : public DualRefCounted<ConnectedSubchannel> {
  public:
   ~ConnectedSubchannel() override {
@@ -1070,7 +156,7 @@ class NewSubchannel::ConnectedSubchannel
   }
 
   const ChannelArgs& args() const { return args_; }
-  NewSubchannel* subchannel() const { return subchannel_.get(); }
+  Subchannel* subchannel() const { return subchannel_.get(); }
 
   virtual void StartWatch(
       grpc_pollset_set* interested_parties,
@@ -1086,6 +172,7 @@ class NewSubchannel::ConnectedSubchannel
                                          grpc_error_handle* error) = 0;
   virtual void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) = 0;
 
+  absl::string_view security_level() const { return security_level_; }
   // Returns true if there is quota for another RPC to start on this
   // connection.
   GRPC_MUST_USE_RESULT bool SetMaxConcurrentStreams(
@@ -1107,7 +194,7 @@ class NewSubchannel::ConnectedSubchannel
   bool ReturnQuotaForRpc() { return stream_limiter_.ReturnQuotaForRpc(); }
 
  protected:
-  explicit ConnectedSubchannel(WeakRefCountedPtr<NewSubchannel> subchannel,
+  explicit ConnectedSubchannel(WeakRefCountedPtr<Subchannel> subchannel,
                                const ChannelArgs& args,
                                uint32_t max_concurrent_streams)
       : DualRefCounted<ConnectedSubchannel>(
@@ -1115,23 +202,24 @@ class NewSubchannel::ConnectedSubchannel
                                                          : nullptr),
         subchannel_(std::move(subchannel)),
         args_(args),
+        security_level_(GetSecurityLevelFromArgs(args)),
         stream_limiter_(max_concurrent_streams) {}
 
  private:
-  WeakRefCountedPtr<NewSubchannel> subchannel_;
+  WeakRefCountedPtr<Subchannel> subchannel_;
   ChannelArgs args_;
+  const absl::string_view security_level_;
   SubchannelStreamLimiter stream_limiter_;
 };
 
 //
-// NewSubchannel::LegacyConnectedSubchannel
+// Subchannel::LegacyConnectedSubchannel
 //
 
-class NewSubchannel::LegacyConnectedSubchannel final
-    : public ConnectedSubchannel {
+class Subchannel::LegacyConnectedSubchannel final : public ConnectedSubchannel {
  public:
   LegacyConnectedSubchannel(
-      WeakRefCountedPtr<NewSubchannel> subchannel,
+      WeakRefCountedPtr<Subchannel> subchannel,
       RefCountedPtr<grpc_channel_stack> channel_stack, const ChannelArgs& args,
       RefCountedPtr<channelz::SubchannelNode> channelz_node,
       uint32_t max_concurrent_streams)
@@ -1236,10 +324,10 @@ class NewSubchannel::LegacyConnectedSubchannel final
 };
 
 //
-// NewSubchannel::LegacyConnectedSubchannel::SubchannelCall
+// Subchannel::LegacyConnectedSubchannel::SubchannelCall
 //
 
-NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::SubchannelCall(
+Subchannel::LegacyConnectedSubchannel::SubchannelCall::SubchannelCall(
     RefCountedPtr<LegacyConnectedSubchannel> connected_subchannel,
     CreateCallArgs args, grpc_error_handle* error)
     : connected_subchannel_(std::move(connected_subchannel)),
@@ -1268,7 +356,7 @@ NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::SubchannelCall(
   }
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::
     StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch) {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << connected_subchannel_->subchannel() << " connection "
@@ -1283,23 +371,23 @@ void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
   top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::
     SetAfterCallStackDestroy(grpc_closure* closure) {
   GRPC_CHECK_EQ(after_call_stack_destroy_, nullptr);
   GRPC_CHECK_NE(closure, nullptr);
   after_call_stack_destroy_ = closure;
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::Unref() {
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::Unref() {
   GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::Unref(
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::Unref(
     const DebugLocation& /*location*/, const char* reason) {
   GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::Destroy(
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::Destroy(
     void* arg, grpc_error_handle /*error*/) {
   SubchannelCall* self = static_cast<SubchannelCall*>(arg);
   // Just in case we didn't already take care of this in the
@@ -1321,7 +409,7 @@ void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::Destroy(
   // stack.
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::
     MaybeInterceptRecvTrailingMetadata(grpc_transport_stream_op_batch* batch) {
   // only intercept payloads with recv trailing.
   if (!batch->recv_trailing_metadata) return;
@@ -1337,7 +425,21 @@ void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
       &recv_trailing_metadata_ready_;
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
+namespace {
+
+// Sets *status based on the rest of the parameters.
+void GetCallStatus(grpc_status_code* status, Timestamp deadline,
+                   grpc_metadata_batch* md_batch, grpc_error_handle error) {
+  if (!error.ok()) {
+    grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
+  } else {
+    *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
+  }
+}
+
+}  // namespace
+
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::
     RecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
   SubchannelCall* call = static_cast<SubchannelCall*>(arg);
   GRPC_CHECK_NE(call->recv_trailing_metadata_, nullptr);
@@ -1359,8 +461,7 @@ void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
   Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_, error);
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    MaybeReturnQuota() {
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::MaybeReturnQuota() {
   if (returned_quota_) return;  // Already returned.
   returned_quota_ = true;
   GRPC_TRACE_LOG(subchannel_call, INFO)
@@ -1372,23 +473,23 @@ void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
   }
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::
     IncrementRefCount() {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void NewSubchannel::LegacyConnectedSubchannel::SubchannelCall::
-    IncrementRefCount(const DebugLocation& /*location*/, const char* reason) {
+void Subchannel::LegacyConnectedSubchannel::SubchannelCall::IncrementRefCount(
+    const DebugLocation& /*location*/, const char* reason) {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
 //
-// NewSubchannel::QueuedCall
+// Subchannel::QueuedCall
 //
 
-class NewSubchannel::QueuedCall final : public Subchannel::Call {
+class Subchannel::QueuedCall final : public Subchannel::Call {
  public:
-  QueuedCall(WeakRefCountedPtr<NewSubchannel> subchannel, CreateCallArgs args);
+  QueuedCall(WeakRefCountedPtr<Subchannel> subchannel, CreateCallArgs args);
   ~QueuedCall() override;
 
   void StartTransportStreamOpBatch(
@@ -1407,10 +508,10 @@ class NewSubchannel::QueuedCall final : public Subchannel::Call {
   }
 
   void ResumeOnConnectionLocked(ConnectedSubchannel* connected_subchannel)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&NewSubchannel::mu_);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&Subchannel::mu_);
 
   void FailLocked(absl::Status status)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&NewSubchannel::mu_);
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&Subchannel::mu_);
 
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
@@ -1429,7 +530,7 @@ class NewSubchannel::QueuedCall final : public Subchannel::Call {
   static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
 
   RefCount ref_count_;
-  WeakRefCountedPtr<NewSubchannel> subchannel_;
+  WeakRefCountedPtr<Subchannel> subchannel_;
   CreateCallArgs args_;
 
   // Note that unlike in the resolver and LB code, the subchannel code
@@ -1438,7 +539,7 @@ class NewSubchannel::QueuedCall final : public Subchannel::Call {
   // and try to resume it before buffered_call_ contains any batches.
   // In that case, we will not be holding the call combiner here, so we
   // need a mutex for synchronization.
-  Mutex mu_ ABSL_ACQUIRED_AFTER(NewSubchannel::mu_);
+  Mutex mu_ ABSL_ACQUIRED_AFTER(Subchannel::mu_);
   grpc_closure* after_call_stack_destroy_ ABSL_GUARDED_BY(&mu_) = nullptr;
   grpc_error_handle cancel_error_ ABSL_GUARDED_BY(&mu_);
   BufferedCall buffered_call_ ABSL_GUARDED_BY(&mu_);
@@ -1451,7 +552,7 @@ class NewSubchannel::QueuedCall final : public Subchannel::Call {
   // don't try to dequeue this call after it's been cancelled.
   QueuedCall*& queue_entry_;
 
-  Canceller* canceller_ ABSL_GUARDED_BY(&NewSubchannel::mu_);
+  Canceller* canceller_ ABSL_GUARDED_BY(&Subchannel::mu_);
 
   std::atomic<bool> is_retriable_{false};
   grpc_closure recv_trailing_metadata_ready_;
@@ -1467,7 +568,7 @@ class NewSubchannel::QueuedCall final : public Subchannel::Call {
 // the call is cancelled.  In that case, it removes the call from the
 // queue and fails any pending batches, thus immediately releasing the
 // call combiner and allowing the cancellation to proceed.
-class NewSubchannel::QueuedCall::Canceller final {
+class Subchannel::QueuedCall::Canceller final {
  public:
   explicit Canceller(RefCountedPtr<QueuedCall> call) : call_(std::move(call)) {
     GRPC_CLOSURE_INIT(&cancel_, CancelLocked, this, nullptr);
@@ -1479,7 +580,7 @@ class NewSubchannel::QueuedCall::Canceller final {
     auto* self = static_cast<Canceller*>(arg);
     bool cancelled = false;
     {
-      MutexLock lock(&self->call_->subchannel_->mu_);
+      MutexLock lock(self->call_->subchannel_->mu_);
       if (self->call_->canceller_ == self && !error.ok()) {
         GRPC_TRACE_LOG(subchannel_call, INFO)
             << "subchannel " << self->call_->subchannel_.get()
@@ -1491,7 +592,7 @@ class NewSubchannel::QueuedCall::Canceller final {
       }
     }
     if (cancelled) {
-      MutexLock lock(&self->call_->mu_);
+      MutexLock lock(self->call_->mu_);
       // Fail pending batches on the call.
       self->call_->buffered_call_.Fail(
           error, BufferedCall::YieldCallCombinerIfPendingBatchesFound);
@@ -1503,8 +604,8 @@ class NewSubchannel::QueuedCall::Canceller final {
   grpc_closure cancel_;
 };
 
-NewSubchannel::QueuedCall::QueuedCall(
-    WeakRefCountedPtr<NewSubchannel> subchannel, CreateCallArgs args)
+Subchannel::QueuedCall::QueuedCall(WeakRefCountedPtr<Subchannel> subchannel,
+                                   CreateCallArgs args)
     : subchannel_(std::move(subchannel)),
       args_(args),
       buffered_call_(args_.call_combiner, &subchannel_call_trace),
@@ -1515,7 +616,7 @@ NewSubchannel::QueuedCall::QueuedCall(
   canceller_ = new Canceller(Ref().TakeAsSubclass<QueuedCall>());
 }
 
-NewSubchannel::QueuedCall::~QueuedCall() {
+Subchannel::QueuedCall::~QueuedCall() {
   GRPC_TRACE_LOG(subchannel_call, INFO) << "subchannel " << subchannel_.get()
                                         << ": destroying queued call " << this;
   if (after_call_stack_destroy_ != nullptr) {
@@ -1523,10 +624,9 @@ NewSubchannel::QueuedCall::~QueuedCall() {
   }
 }
 
-void NewSubchannel::QueuedCall::SetAfterCallStackDestroy(
-    grpc_closure* closure) {
+void Subchannel::QueuedCall::SetAfterCallStackDestroy(grpc_closure* closure) {
   GRPC_CHECK_NE(closure, nullptr);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (subchannel_call_ != nullptr) {
     subchannel_call_->SetAfterCallStackDestroy(closure);
   } else {
@@ -1535,13 +635,13 @@ void NewSubchannel::QueuedCall::SetAfterCallStackDestroy(
   }
 }
 
-void NewSubchannel::QueuedCall::StartTransportStreamOpBatch(
+void Subchannel::QueuedCall::StartTransportStreamOpBatch(
     grpc_transport_stream_op_batch* batch) {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << subchannel_.get() << " queued call " << this
       << ": starting batch: "
       << grpc_transport_stream_op_batch_string(batch, false);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // If we already have a real subchannel call, pass the batch down to it.
   if (subchannel_call_ != nullptr) {
     subchannel_call_->StartTransportStreamOpBatch(batch);
@@ -1588,7 +688,7 @@ void NewSubchannel::QueuedCall::StartTransportStreamOpBatch(
   }
 }
 
-void NewSubchannel::QueuedCall::RecvTrailingMetadataReady(
+void Subchannel::QueuedCall::RecvTrailingMetadataReady(
     void* arg, grpc_error_handle error) {
   QueuedCall* call = static_cast<QueuedCall*>(arg);
   GRPC_CHECK_NE(call->recv_trailing_metadata_, nullptr);
@@ -1599,14 +699,14 @@ void NewSubchannel::QueuedCall::RecvTrailingMetadataReady(
   Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_, error);
 }
 
-void NewSubchannel::QueuedCall::ResumeOnConnectionLocked(
+void Subchannel::QueuedCall::ResumeOnConnectionLocked(
     ConnectedSubchannel* connected_subchannel) {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << subchannel_.get() << " queued call " << this
       << ": resuming on connected_subchannel " << connected_subchannel;
   canceller_ = nullptr;
   queue_entry_ = nullptr;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_error_handle error;
   subchannel_call_ = connected_subchannel->CreateCall(args_, &error);
   if (after_call_stack_destroy_ != nullptr) {
@@ -1616,7 +716,7 @@ void NewSubchannel::QueuedCall::ResumeOnConnectionLocked(
   // It's possible that the subchannel will get quota for the call
   // and try to resume it before buffered_call_ contains any batches.
   // In that case, we will not be holding the call combiner here, so we
-  // must not yeild it.  That's why we use
+  // must not yield it.  That's why we use
   // YieldCallCombinerIfPendingBatchesFound here.
   if (!error.ok()) {
     buffered_call_.Fail(error,
@@ -1632,24 +732,24 @@ void NewSubchannel::QueuedCall::ResumeOnConnectionLocked(
   }
 }
 
-void NewSubchannel::QueuedCall::FailLocked(absl::Status status) {
+void Subchannel::QueuedCall::FailLocked(absl::Status status) {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << subchannel_.get() << " queued call " << this
       << ": failing: " << status;
   canceller_ = nullptr;
   queue_entry_ = nullptr;
   is_retriable_.store(true);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   cancel_error_ = status;
   buffered_call_.Fail(status,
                       BufferedCall::YieldCallCombinerIfPendingBatchesFound);
 }
 
 //
-// NewSubchannel::NewConnectedSubchannel
+// Subchannel::NewConnectedSubchannel
 //
 
-class NewSubchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
+class Subchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
  public:
   class TransportCallDestination final : public CallDestination {
    public:
@@ -1669,7 +769,7 @@ class NewSubchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
   };
 
   NewConnectedSubchannel(
-      WeakRefCountedPtr<NewSubchannel> subchannel,
+      WeakRefCountedPtr<Subchannel> subchannel,
       RefCountedPtr<UnstartedCallDestination> call_destination,
       RefCountedPtr<TransportCallDestination> transport,
       const ChannelArgs& args, uint32_t max_concurrent_streams)
@@ -1690,7 +790,8 @@ class NewSubchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
   }
 
   void Ping(absl::AnyInvocable<void(absl::Status)>) override {
-    // TODO(ctiller): add new transport API for this in v3 stack
+    // TODO(akshitpatel) : [PH2][P2][Client] : add new transport API for this in
+    // v3 stack
     Crash("not implemented");
   }
 
@@ -1713,10 +814,10 @@ class NewSubchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
 };
 
 //
-// NewSubchannel::ConnectionStateWatcher
+// Subchannel::ConnectionStateWatcher
 //
 
-class NewSubchannel::ConnectionStateWatcher final
+class Subchannel::ConnectionStateWatcher final
     : public Transport::StateWatcher {
  public:
   explicit ConnectionStateWatcher(
@@ -1725,12 +826,22 @@ class NewSubchannel::ConnectionStateWatcher final
 
   void OnDisconnect(absl::Status status,
                     DisconnectInfo disconnect_info) override {
-    NewSubchannel* subchannel = connected_subchannel_->subchannel();
+    Subchannel* subchannel = connected_subchannel_->subchannel();
     GRPC_TRACE_LOG(subchannel, INFO)
         << "subchannel " << subchannel << " " << subchannel->key_.ToString()
         << ": connected subchannel " << connected_subchannel_.get()
-        << " reports disconnection: " << status;
-    MutexLock lock(&subchannel->mu_);
+        << " reports disconnection: " << status
+        << " (reason=" << disconnect_info.reason << ", http2_error_code="
+        << (disconnect_info.http2_error_code.has_value()
+                ? http2::Http2Status::DebugGetCode(
+                      *disconnect_info.http2_error_code)
+                : "<unset>")
+        << ", keepalive_time="
+        << (disconnect_info.keepalive_time.has_value()
+                ? disconnect_info.keepalive_time->ToString()
+                : "<unset>")
+        << ")";
+    MutexLock lock(subchannel->mu_);
     // Handle keepalive update.
     if (disconnect_info.keepalive_time.has_value()) {
       subchannel->ThrottleKeepaliveTimeLocked(*disconnect_info.keepalive_time);
@@ -1739,6 +850,50 @@ class NewSubchannel::ConnectionStateWatcher final
     }
     // Remove the connection from the subchannel's list of connections.
     subchannel->RemoveConnectionLocked(connected_subchannel_.get());
+    if (subchannel->stats_plugin_group_ != nullptr) {
+      // Determine disconnect reason from DisconnectInfo
+      std::string disconnect_reason;
+      if (subchannel->shutdown_) {
+        disconnect_reason = "subchannel shutdown";
+      } else {
+        switch (disconnect_info.reason) {
+          case DisconnectReason::kGoaway:
+            if (disconnect_info.http2_error_code.has_value()) {
+              disconnect_reason = absl::StrCat(
+                  "GOAWAY ", http2::Http2Status::DebugGetCode(
+                                 *disconnect_info.http2_error_code));
+            } else {
+              disconnect_reason = "GOAWAY UNKNOWN";
+            }
+            break;
+          case DisconnectReason::kConnectionReset:
+            disconnect_reason = "connection reset";
+            break;
+          case DisconnectReason::kConnectionTimedOut:
+            disconnect_reason = "connection timed out";
+            break;
+          case DisconnectReason::kConnectionAborted:
+            disconnect_reason = "connection aborted";
+            break;
+          case DisconnectReason::kSocketError:
+            disconnect_reason = "socket error";
+            break;
+          case DisconnectReason::kUnknown:
+            disconnect_reason = "unknown";
+            break;
+        }
+      }
+      auto scope = subchannel->stats_plugin_group_->GetCollectionScope();
+      SubchannelMetricsDomainDisconnections::GetStorage(
+          scope, subchannel->target_, subchannel->backend_service_,
+          subchannel->locality_, disconnect_reason)
+          ->Increment(SubchannelMetricsDomainDisconnections::kDisconnections);
+      SubchannelConnectionsDomainOpenConnections::GetStorage(
+          scope, subchannel->target_, connected_subchannel_->security_level(),
+          subchannel->backend_service_, subchannel->locality_)
+          ->Decrement(
+              SubchannelConnectionsDomainOpenConnections::kOpenConnections);
+    }
     // If this was the last connection, then fail all queued RPCs and
     // update the connectivity state.
     if (subchannel->connections_.empty()) {
@@ -1756,7 +911,7 @@ class NewSubchannel::ConnectionStateWatcher final
       uint32_t max_concurrent_streams,
       std::unique_ptr<MaxConcurrentStreamsUpdateDoneHandle> /*on_done*/)
       override {
-    NewSubchannel* subchannel = connected_subchannel_->subchannel();
+    Subchannel* subchannel = connected_subchannel_->subchannel();
     GRPC_TRACE_LOG(subchannel, INFO)
         << "subchannel " << subchannel << " " << subchannel->key_.ToString()
         << ": connection " << connected_subchannel_.get()
@@ -1776,20 +931,20 @@ class NewSubchannel::ConnectionStateWatcher final
 };
 
 //
-// NewSubchannel::ConnectivityStateWatcherList
+// Subchannel::ConnectivityStateWatcherList
 //
 
-void NewSubchannel::ConnectivityStateWatcherList::AddWatcherLocked(
+void Subchannel::ConnectivityStateWatcherList::AddWatcherLocked(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
   watchers_.insert(std::move(watcher));
 }
 
-void NewSubchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
+void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
     ConnectivityStateWatcherInterface* watcher) {
   watchers_.erase(watcher);
 }
 
-void NewSubchannel::ConnectivityStateWatcherList::NotifyLocked(
+void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
   for (const auto& watcher : watchers_) {
     subchannel_->work_serializer_.Run([watcher, state, status]() {
@@ -1798,7 +953,7 @@ void NewSubchannel::ConnectivityStateWatcherList::NotifyLocked(
   }
 }
 
-void NewSubchannel::ConnectivityStateWatcherList::NotifyOnKeepaliveUpdateLocked(
+void Subchannel::ConnectivityStateWatcherList::NotifyOnKeepaliveUpdateLocked(
     Duration new_keepalive_time) {
   for (const auto& watcher : watchers_) {
     subchannel_->work_serializer_.Run([watcher, new_keepalive_time]() {
@@ -1808,7 +963,7 @@ void NewSubchannel::ConnectivityStateWatcherList::NotifyOnKeepaliveUpdateLocked(
 }
 
 uint32_t
-NewSubchannel::ConnectivityStateWatcherList::GetMaxConnectionsPerSubchannel()
+Subchannel::ConnectivityStateWatcherList::GetMaxConnectionsPerSubchannel()
     const {
   uint32_t max_connections_per_subchannel = 1;
   for (const auto& watcher : watchers_) {
@@ -1820,13 +975,56 @@ NewSubchannel::ConnectivityStateWatcherList::GetMaxConnectionsPerSubchannel()
 }
 
 //
-// NewSubchannel
+// Subchannel
 //
 
-NewSubchannel::NewSubchannel(SubchannelKey key,
-                             OrphanablePtr<SubchannelConnector> connector,
-                             const ChannelArgs& args)
-    : key_(std::move(key)),
+namespace {
+
+BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
+                                           Duration* min_connect_timeout) {
+  const std::optional<Duration> fixed_reconnect_backoff =
+      args.GetDurationFromIntMillis("grpc.testing.fixed_reconnect_backoff_ms");
+  if (fixed_reconnect_backoff.has_value()) {
+    const Duration backoff =
+        std::max(Duration::Milliseconds(100), *fixed_reconnect_backoff);
+    *min_connect_timeout = backoff;
+    return BackOff::Options()
+        .set_initial_backoff(backoff)
+        .set_multiplier(1.0)
+        .set_jitter(0.0)
+        .set_max_backoff(backoff);
+  }
+  const Duration initial_backoff = std::max(
+      Duration::Milliseconds(100),
+      args.GetDurationFromIntMillis(GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)
+          .value_or(Duration::Seconds(
+              GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS)));
+  *min_connect_timeout =
+      std::max(Duration::Milliseconds(100),
+               args.GetDurationFromIntMillis(GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)
+                   .value_or(Duration::Seconds(
+                       GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS)));
+  const Duration max_backoff =
+      std::max(Duration::Milliseconds(100),
+               args.GetDurationFromIntMillis(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)
+                   .value_or(Duration::Seconds(
+                       GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS)));
+  return BackOff::Options()
+      .set_initial_backoff(initial_backoff)
+      .set_multiplier(GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
+      .set_jitter(GRPC_SUBCHANNEL_RECONNECT_JITTER)
+      .set_max_backoff(max_backoff);
+}
+
+}  // namespace
+
+Subchannel::Subchannel(SubchannelKey key,
+                       OrphanablePtr<SubchannelConnector> connector,
+                       const ChannelArgs& args)
+    : DualRefCounted<Subchannel>(GRPC_TRACE_FLAG_ENABLED(subchannel_refcount)
+                                     ? "Subchannel"
+                                     : nullptr),
+      key_(std::move(key)),
       created_from_endpoint_(args.Contains(GRPC_ARG_SUBCHANNEL_ENDPOINT)),
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
@@ -1834,7 +1032,17 @@ NewSubchannel::NewSubchannel(SubchannelKey key,
       watcher_list_(this),
       work_serializer_(args_.GetObjectRef<EventEngine>()),
       backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)),
-      event_engine_(args_.GetObjectRef<EventEngine>()) {
+      event_engine_(args_.GetObjectRef<EventEngine>()),
+      stats_plugin_group_(
+          args_.GetObjectRef<GlobalStatsPluginRegistry::StatsPluginGroup>()),
+      target_(args_.GetString(GRPC_ARG_DEFAULT_AUTHORITY).value_or("")),
+      backend_service_(args_.GetString(GRPC_ARG_BACKEND_SERVICE).value_or("")),
+      locality_(args_.GetString(GRPC_ARG_LB_LOCALITY).value_or("")) {
+  if (stats_plugin_group_ != nullptr) {
+    attempts_storage_ = SubchannelMetricsDomainAttempts::GetStorage(
+        stats_plugin_group_->GetCollectionScope(), target_, backend_service_,
+        locality_);
+  }
   GRPC_TRACE_LOG(subchannel, INFO)
       << "subchannel " << this << " " << key_.ToString() << ": created";
   // A grpc_init is added here to ensure that grpc_shutdown does not happen
@@ -1873,7 +1081,7 @@ NewSubchannel::NewSubchannel(SubchannelKey key,
   }
 }
 
-NewSubchannel::~NewSubchannel() {
+Subchannel::~Subchannel() {
   if (channelz_node_ != nullptr) {
     GRPC_CHANNELZ_LOG(channelz_node_) << "Subchannel destroyed";
     channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
@@ -1884,18 +1092,18 @@ NewSubchannel::~NewSubchannel() {
   ShutdownInternally();
 }
 
-RefCountedPtr<Subchannel> NewSubchannel::Create(
+RefCountedPtr<Subchannel> Subchannel::Create(
     OrphanablePtr<SubchannelConnector> connector,
     const grpc_resolved_address& address, const ChannelArgs& args) {
   SubchannelKey key(address, args);
   auto* subchannel_pool = args.GetObject<SubchannelPoolInterface>();
   GRPC_CHECK_NE(subchannel_pool, nullptr);
-  RefCountedPtr<NewSubchannel> c =
-      subchannel_pool->FindSubchannel(key).TakeAsSubclass<NewSubchannel>();
+  RefCountedPtr<Subchannel> c =
+      subchannel_pool->FindSubchannel(key).TakeAsSubclass<Subchannel>();
   if (c != nullptr) {
     return c;
   }
-  c = MakeRefCounted<NewSubchannel>(std::move(key), std::move(connector), args);
+  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.
@@ -1909,19 +1117,19 @@ RefCountedPtr<Subchannel> NewSubchannel::Create(
   // Otherwise, in case of a registration race, unreffing c in
   // RegisterSubchannel() will cause c to be tried to be unregistered, while
   // its key maps to a different subchannel.
-  RefCountedPtr<NewSubchannel> registered =
+  RefCountedPtr<Subchannel> registered =
       subchannel_pool->RegisterSubchannel(c->key_, c)
-          .TakeAsSubclass<NewSubchannel>();
+          .TakeAsSubclass<Subchannel>();
   if (registered == c) c->subchannel_pool_ = subchannel_pool->Ref();
   return registered;
 }
 
-void NewSubchannel::ThrottleKeepaliveTime(Duration new_keepalive_time) {
-  MutexLock lock(&mu_);
+void Subchannel::ThrottleKeepaliveTime(Duration new_keepalive_time) {
+  MutexLock lock(mu_);
   ThrottleKeepaliveTimeLocked(new_keepalive_time);
 }
 
-void NewSubchannel::ThrottleKeepaliveTimeLocked(Duration new_keepalive_time) {
+void Subchannel::ThrottleKeepaliveTimeLocked(Duration new_keepalive_time) {
   // Only update the value if the new keepalive time is larger.
   if (new_keepalive_time > keepalive_time_) {
     keepalive_time_ = new_keepalive_time;
@@ -1932,13 +1140,13 @@ void NewSubchannel::ThrottleKeepaliveTimeLocked(Duration new_keepalive_time) {
   }
 }
 
-channelz::SubchannelNode* NewSubchannel::channelz_node() {
+channelz::SubchannelNode* Subchannel::channelz_node() {
   return channelz_node_.get();
 }
 
-void NewSubchannel::WatchConnectivityState(
+void Subchannel::WatchConnectivityState(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
   if (interested_parties != nullptr) {
     grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
@@ -1954,9 +1162,9 @@ void NewSubchannel::WatchConnectivityState(
   RetryQueuedRpcsLocked();
 }
 
-void NewSubchannel::CancelConnectivityStateWatch(
+void Subchannel::CancelConnectivityStateWatch(
     ConnectivityStateWatcherInterface* watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
   if (interested_parties != nullptr) {
     grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
@@ -1964,24 +1172,24 @@ void NewSubchannel::CancelConnectivityStateWatch(
   watcher_list_.RemoveWatcherLocked(watcher);
 }
 
-void NewSubchannel::RequestConnection() {
+void Subchannel::RequestConnection() {
   GRPC_TRACE_LOG(subchannel, INFO)
       << "subchannel " << this << " " << key_.ToString()
       << ": RequestConnection()";
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (state_ == GRPC_CHANNEL_IDLE) {
     StartConnectingLocked();
   }
 }
 
-void NewSubchannel::ResetBackoff() {
+void Subchannel::ResetBackoff() {
   GRPC_TRACE_LOG(subchannel, INFO)
       << "subchannel " << this << " " << key_.ToString() << ": ResetBackoff()";
   // Hold a ref to ensure cancellation and subsequent deletion of the closure
   // does not eliminate the last ref and destroy the Subchannel before the
   // method returns.
   auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   backoff_.Reset();
   if (retry_timer_handle_.has_value() &&
       event_engine_->Cancel(*retry_timer_handle_)) {
@@ -1991,7 +1199,7 @@ void NewSubchannel::ResetBackoff() {
   }
 }
 
-void NewSubchannel::Orphaned() {
+void Subchannel::Orphaned() {
   GRPC_TRACE_LOG(subchannel, INFO)
       << "subchannel " << this << " " << key_.ToString() << ": shutting down";
   // The subchannel_pool is only used once here in this subchannel, so the
@@ -2000,7 +1208,7 @@ void NewSubchannel::Orphaned() {
     subchannel_pool_->UnregisterSubchannel(key_, this);
     subchannel_pool_.reset();
   }
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_CHECK(!shutdown_);
   shutdown_ = true;
   connector_.reset();
@@ -2010,16 +1218,16 @@ void NewSubchannel::Orphaned() {
   }
 }
 
-void NewSubchannel::GetOrAddDataProducer(
+void Subchannel::GetOrAddDataProducer(
     UniqueTypeName type,
     std::function<void(DataProducerInterface**)> get_or_add) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = data_producer_map_.emplace(type, nullptr).first;
   get_or_add(&it->second);
 }
 
-void NewSubchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
-  MutexLock lock(&mu_);
+void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
+  MutexLock lock(mu_);
   auto it = data_producer_map_.find(data_producer->type());
   if (it != data_producer_map_.end() && it->second == data_producer) {
     data_producer_map_.erase(it);
@@ -2037,12 +1245,12 @@ absl::Status PrependAddressToStatusMessage(const SubchannelKey& key,
 
 }  // namespace
 
-void NewSubchannel::SetLastFailureLocked(const absl::Status& status) {
+void Subchannel::SetLastFailureLocked(const absl::Status& status) {
   // Augment status message to include IP address.
   last_failure_status_ = PrependAddressToStatusMessage(key_, status);
 }
 
-grpc_connectivity_state NewSubchannel::ComputeConnectivityStateLocked() const {
+grpc_connectivity_state Subchannel::ComputeConnectivityStateLocked() const {
   // If we have at least one connection, report READY.
   if (!connections_.empty()) return GRPC_CHANNEL_READY;
   // If we were created from an endpoint and the connection is closed,
@@ -2059,13 +1267,13 @@ grpc_connectivity_state NewSubchannel::ComputeConnectivityStateLocked() const {
   return GRPC_CHANNEL_IDLE;
 }
 
-absl::Status NewSubchannel::ConnectivityStatusToReportLocked() const {
+absl::Status Subchannel::ConnectivityStatusToReportLocked() const {
   // Report status in TRANSIENT_FAILURE state.
   if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE) return last_failure_status_;
   return absl::OkStatus();
 }
 
-void NewSubchannel::MaybeUpdateConnectivityStateLocked() {
+void Subchannel::MaybeUpdateConnectivityStateLocked() {
   // Determine what state we are in.
   grpc_connectivity_state new_state = ComputeConnectivityStateLocked();
   // If we're already in that state, no need to report a change.
@@ -2093,7 +1301,7 @@ void NewSubchannel::MaybeUpdateConnectivityStateLocked() {
   watcher_list_.NotifyLocked(new_state, status);
 }
 
-bool NewSubchannel::RemoveConnectionLocked(
+bool Subchannel::RemoveConnectionLocked(
     ConnectedSubchannel* connected_subchannel) {
   for (auto it = connections_.begin(); it != connections_.end(); ++it) {
     if (*it == connected_subchannel) {
@@ -2107,12 +1315,12 @@ bool NewSubchannel::RemoveConnectionLocked(
   return false;
 }
 
-void NewSubchannel::OnRetryTimer() {
-  MutexLock lock(&mu_);
+void Subchannel::OnRetryTimer() {
+  MutexLock lock(mu_);
   OnRetryTimerLocked();
 }
 
-void NewSubchannel::OnRetryTimerLocked() {
+void Subchannel::OnRetryTimerLocked() {
   retry_timer_handle_.reset();
   if (shutdown_) return;
   GRPC_TRACE_LOG(subchannel, INFO)
@@ -2122,7 +1330,7 @@ void NewSubchannel::OnRetryTimerLocked() {
   MaybeUpdateConnectivityStateLocked();
 }
 
-void NewSubchannel::StartConnectingLocked() {
+void Subchannel::StartConnectingLocked() {
   // Set next attempt time.
   const Timestamp now = Timestamp::Now();
   const Timestamp min_deadline = now + min_connect_timeout_;
@@ -2141,16 +1349,16 @@ void NewSubchannel::StartConnectingLocked() {
   connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
-void NewSubchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
-  WeakRefCountedPtr<NewSubchannel> c(static_cast<NewSubchannel*>(arg));
+void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
+  WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
   {
-    MutexLock lock(&c->mu_);
+    MutexLock lock(c->mu_);
     c->OnConnectingFinishedLocked(error);
   }
   c.reset(DEBUG_LOCATION, "Connect");
 }
 
-void NewSubchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
+void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   connection_attempt_in_flight_ = false;
   if (shutdown_) {
     connecting_result_.Reset();
@@ -2172,11 +1380,16 @@ void NewSubchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
                   "remaining in TRANSIENT_FAILURE"
                 : ", backing off for " +
                       std::to_string(time_until_next_attempt.millis()) + " ms");
+    // Record failed connection attempt
+    if (attempts_storage_ != nullptr) {
+      attempts_storage_->Increment(
+          SubchannelMetricsDomainAttempts::kConnectionAttemptsFailed);
+    }
     if (!created_from_endpoint_) {
       retry_timer_handle_ = event_engine_->RunAfter(
           time_until_next_attempt,
           [self = WeakRef(DEBUG_LOCATION, "RetryTimer")
-                      .TakeAsSubclass<NewSubchannel>()]() mutable {
+                      .TakeAsSubclass<Subchannel>()]() mutable {
             {
               ExecCtx exec_ctx;
               self->OnRetryTimer();
@@ -2190,12 +1403,12 @@ void NewSubchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
             }
           });
     }
-    SetLastFailureLocked(grpc_error_to_absl_status(error));
+    SetLastFailureLocked(error);
     MaybeUpdateConnectivityStateLocked();
   }
 }
 
-bool NewSubchannel::PublishTransportLocked() {
+bool Subchannel::PublishTransportLocked() {
   auto socket_node = connecting_result_.transport->GetSocketNode();
   Transport* transport = connecting_result_.transport;
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
@@ -2217,8 +1430,9 @@ bool NewSubchannel::PublishTransportLocked() {
       return false;
     }
     connected_subchannel = MakeRefCounted<LegacyConnectedSubchannel>(
-        WeakRef().TakeAsSubclass<NewSubchannel>(), std::move(*stack), args_,
-        channelz_node_, connecting_result_.max_concurrent_streams);
+        WeakRef().TakeAsSubclass<Subchannel>(), std::move(*stack),
+        connecting_result_.channel_args, channelz_node_,
+        connecting_result_.max_concurrent_streams);
   } else {
     OrphanablePtr<ClientTransport> transport(
         std::exchange(connecting_result_.transport, nullptr)
@@ -2257,8 +1471,8 @@ bool NewSubchannel::PublishTransportLocked() {
       return false;
     }
     connected_subchannel = MakeRefCounted<NewConnectedSubchannel>(
-        WeakRef().TakeAsSubclass<NewSubchannel>(), std::move(*call_destination),
-        std::move(transport_destination), args_,
+        WeakRef().TakeAsSubclass<Subchannel>(), std::move(*call_destination),
+        std::move(transport_destination), connecting_result_.channel_args,
         connecting_result_.max_concurrent_streams);
   }
   connecting_result_.Reset();
@@ -2275,6 +1489,19 @@ bool NewSubchannel::PublishTransportLocked() {
       socket_node->AddParent(channelz_node_.get());
     }
   }
+  // Record successful connection attempt
+  if (attempts_storage_ != nullptr) {
+    attempts_storage_->Increment(
+        SubchannelMetricsDomainAttempts::kConnectionAttemptsSucceeded);
+  }
+  if (stats_plugin_group_ != nullptr) {
+    auto scope = stats_plugin_group_->GetCollectionScope();
+    SubchannelConnectionsDomainOpenConnections::GetStorage(
+        scope, target_, connected_subchannel->security_level(),
+        backend_service_, locality_)
+        ->Increment(
+            SubchannelConnectionsDomainOpenConnections::kOpenConnections);
+  }
   transport->StartWatch(
       MakeRefCounted<ConnectionStateWatcher>(connected_subchannel->WeakRef()));
   connections_.push_back(std::move(connected_subchannel));
@@ -2283,11 +1510,11 @@ bool NewSubchannel::PublishTransportLocked() {
   return true;
 }
 
-RefCountedPtr<Subchannel::Call> NewSubchannel::CreateCall(
+RefCountedPtr<Subchannel::Call> Subchannel::CreateCall(
     CreateCallArgs args, grpc_error_handle* error) {
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // If we hit a race condition where the LB picker chose the subchannel
     // at the same time as the last connection was closed, then tell the
     // channel to re-queue the pick.
@@ -2300,7 +1527,7 @@ RefCountedPtr<Subchannel::Call> NewSubchannel::CreateCall(
     if (connected_subchannel == nullptr) {
       // The QueuedCall object adds itself to queued_calls_.
       auto queued_call = RefCountedPtr<QueuedCall>(args.arena->New<QueuedCall>(
-          WeakRef().TakeAsSubclass<NewSubchannel>(), args));
+          WeakRef().TakeAsSubclass<Subchannel>(), args));
       MaybeFailAllQueuedRpcsLocked();
       return queued_call;
     }
@@ -2312,11 +1539,11 @@ RefCountedPtr<Subchannel::Call> NewSubchannel::CreateCall(
   return connected_subchannel->CreateCall(args, error);
 }
 
-RefCountedPtr<UnstartedCallDestination> NewSubchannel::call_destination() {
-  // TODO(roth): Implement connection scaling for v3.
+RefCountedPtr<UnstartedCallDestination> Subchannel::call_destination() {
+  // TODO(roth) : [PH2][P2][Client] : Implement connection scaling for v3.
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!connections_.empty()) connected_subchannel = connections_[0];
   }
   if (connected_subchannel == nullptr) return nullptr;
@@ -2331,8 +1558,8 @@ void TestOnlySetSubchannelAlwaysSendCallsToTransport(bool enabled) {
   g_test_only_always_send_calls_to_transport = enabled;
 }
 
-RefCountedPtr<NewSubchannel::ConnectedSubchannel>
-NewSubchannel::ChooseConnectionLocked() {
+RefCountedPtr<Subchannel::ConnectedSubchannel>
+Subchannel::ChooseConnectionLocked() {
   // Try to find a connection with quota available for the RPC.
   for (auto& connection : connections_) {
     if (connection->GetQuotaForRpc()) return connection;
@@ -2355,13 +1582,13 @@ NewSubchannel::ChooseConnectionLocked() {
   return nullptr;
 }
 
-void NewSubchannel::RetryQueuedRpcs() {
-  MutexLock lock(&mu_);
+void Subchannel::RetryQueuedRpcs() {
+  MutexLock lock(mu_);
   if (shutdown_) return;
   RetryQueuedRpcsLocked();
 }
 
-void NewSubchannel::RetryQueuedRpcsLocked() {
+void Subchannel::RetryQueuedRpcsLocked() {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << this << " " << key_.ToString()
       << ": retrying RPCs from queue, queue size=" << queued_calls_.size();
@@ -2389,7 +1616,7 @@ void NewSubchannel::RetryQueuedRpcsLocked() {
   }
 }
 
-void NewSubchannel::MaybeFailAllQueuedRpcsLocked() {
+void Subchannel::MaybeFailAllQueuedRpcsLocked() {
   bool fail_instead_of_queuing =
       args_.GetInt(GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT)
           .value_or(false);
@@ -2401,7 +1628,7 @@ void NewSubchannel::MaybeFailAllQueuedRpcsLocked() {
   }
 }
 
-void NewSubchannel::FailAllQueuedRpcsLocked(absl::Status status) {
+void Subchannel::FailAllQueuedRpcsLocked(absl::Status status) {
   GRPC_TRACE_LOG(subchannel_call, INFO)
       << "subchannel " << this << ": failing all queued RPCs: " << status;
   status = PrependAddressToStatusMessage(key_, status);
@@ -2411,15 +1638,14 @@ void NewSubchannel::FailAllQueuedRpcsLocked(absl::Status status) {
   queued_calls_.clear();
 }
 
-void NewSubchannel::Ping(absl::AnyInvocable<void(absl::Status)>) {
+void Subchannel::Ping(absl::AnyInvocable<void(absl::Status)>) {
   // TODO(ctiller): Implement
 }
 
-absl::Status NewSubchannel::Ping(grpc_closure* on_initiate,
-                                 grpc_closure* on_ack) {
+absl::Status Subchannel::Ping(grpc_closure* on_initiate, grpc_closure* on_ack) {
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!connections_.empty()) connected_subchannel = connections_[0];
   }
   if (connected_subchannel == nullptr) {
@@ -2429,4 +1655,31 @@ absl::Status NewSubchannel::Ping(grpc_closure* on_initiate,
   return absl::OkStatus();
 }
 
+ChannelArgs Subchannel::MakeSubchannelArgs(
+    const ChannelArgs& channel_args, const ChannelArgs& address_args,
+    const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
+    const std::string& channel_default_authority) {
+  // Note that we start with the channel-level args and then apply the
+  // per-address args, so that if a value is present in both, the one
+  // in the channel-level args is used.  This is particularly important
+  // for the GRPC_ARG_DEFAULT_AUTHORITY arg, which we want to allow
+  // resolvers to set on a per-address basis only if the application
+  // did not explicitly set it at the channel level.
+  return channel_args.UnionWith(address_args)
+      .SetObject(subchannel_pool)
+      // If we haven't already set the default authority arg (i.e., it
+      // was not explicitly set by the application nor overridden by
+      // the resolver), add it from the channel's default.
+      .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, channel_default_authority)
+      // Remove channel args that should not affect subchannel
+      // uniqueness.
+      .Remove(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME)
+      .Remove(GRPC_ARG_INHIBIT_HEALTH_CHECKING)
+      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP)
+      .Remove(GRPC_ARG_CHANNELZ_CHANNEL_NODE)
+      // Remove all keys with the no-subchannel prefix.
+      .RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX);
+}
+
 }  // namespace grpc_core