grpc 1.81.1 → 1.85.0

data/src/core/client_channel/subchannel.h

@@ -28,6 +28,7 @@
 
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/connector.h"
+#include "src/core/client_channel/subchannel_metrics.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -43,6 +44,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/metrics.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/dual_ref_counted.h"
@@ -141,116 +143,25 @@ class Subchannel : public DualRefCounted<Subchannel> {
       OrphanablePtr<SubchannelConnector> connector,
       const grpc_resolved_address& address, const ChannelArgs& args);
 
-  // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
-  // is larger than the subchannel's current keepalive time. The updated value
-  // will have an affect when the subchannel creates a new ConnectedSubchannel.
-  virtual void ThrottleKeepaliveTime(Duration new_keepalive_time) = 0;
-
-  virtual grpc_pollset_set* pollset_set() const = 0;
-
-  virtual channelz::SubchannelNode* channelz_node() = 0;
-
-  virtual const ChannelArgs& args() const = 0;
-
-  virtual std::string address() const = 0;
-
-  // Starts watching the subchannel's connectivity state.
-  // The first callback to the watcher will be delivered ~immediately.
-  // Subsequent callbacks will be delivered as the subchannel's state
-  // changes.
-  // The watcher will be destroyed either when the subchannel is
-  // destroyed or when CancelConnectivityStateWatch() is called.
-  virtual void WatchConnectivityState(
-      RefCountedPtr<ConnectivityStateWatcherInterface> watcher) = 0;
-
-  // Cancels a connectivity state watch.
-  // If the watcher has already been destroyed, this is a no-op.
-  virtual void CancelConnectivityStateWatch(
-      ConnectivityStateWatcherInterface* watcher) = 0;
-
-  // Starts a call in the v1 stack.
-  // Returns null if there is no connected subchannel.
-  struct CreateCallArgs {
-    grpc_polling_entity* pollent;
-    gpr_cycle_counter start_time;
-    Timestamp deadline;
-    Arena* arena;
-    CallCombiner* call_combiner;
-  };
-  virtual RefCountedPtr<Call> CreateCall(CreateCallArgs args,
-                                         grpc_error_handle* error) = 0;
-
-  // Used for calls in the v3 stack.
-  virtual RefCountedPtr<UnstartedCallDestination> call_destination() = 0;
-
-  // Attempt to connect to the backend.  Has no effect if already connected.
-  virtual void RequestConnection() = 0;
-
-  // Resets the connection backoff of the subchannel.
-  virtual void ResetBackoff() = 0;
+  // Do not instantiate directly; use Create() instead.
+  Subchannel(SubchannelKey key, OrphanablePtr<SubchannelConnector> connector,
+             const ChannelArgs& args);
 
-  // Access to data producer map.
-  // We do not hold refs to the data producer; the implementation is
-  // expected to register itself upon construction and remove itself
-  // upon destruction.
-  //
-  // Looks up the current data producer for type and invokes get_or_add()
-  // with a pointer to that producer in the map.  The get_or_add() function
-  // can modify the pointed-to value to update the map.  This provides a
-  // way to either re-use an existing producer or register a new one in
-  // a non-racy way.
-  virtual void GetOrAddDataProducer(
-      UniqueTypeName type,
-      std::function<void(DataProducerInterface**)> get_or_add) = 0;
-  // Removes the data producer from the map, if the current producer for
-  // this type is the specified producer.
-  virtual void RemoveDataProducer(DataProducerInterface* data_producer) = 0;
-
-  virtual std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-  event_engine() = 0;
-
-  // Ping API for v3 stack.
-  virtual void Ping(absl::AnyInvocable<void(absl::Status)> on_ack) = 0;
-  // Ping API for v1 stack.
-  // TODO(roth): Remove this when v3 migration is done.
-  virtual absl::Status Ping(grpc_closure* on_initiate,
-                            grpc_closure* on_ack) = 0;
-
-  // Exposed for testing purposes only.
-  static ChannelArgs MakeSubchannelArgs(
-      const ChannelArgs& channel_args, const ChannelArgs& address_args,
-      const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
-      const std::string& channel_default_authority);
-
- protected:
-  Subchannel();
-};
-
-class OldSubchannel final : public Subchannel {
- public:
-  // Creates a subchannel.
-  static RefCountedPtr<Subchannel> Create(
-      OrphanablePtr<SubchannelConnector> connector,
-      const grpc_resolved_address& address, const ChannelArgs& args);
-
-  // The ctor and dtor are not intended to use directly.
-  OldSubchannel(SubchannelKey key, OrphanablePtr<SubchannelConnector> connector,
-                const ChannelArgs& args);
-  ~OldSubchannel() override;
+  ~Subchannel() override;
 
   // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
   // is larger than the subchannel's current keepalive time. The updated value
   // will have an affect when the subchannel creates a new ConnectedSubchannel.
-  void ThrottleKeepaliveTime(Duration new_keepalive_time) override
+  void ThrottleKeepaliveTime(Duration new_keepalive_time)
       ABSL_LOCKS_EXCLUDED(mu_);
 
-  grpc_pollset_set* pollset_set() const override { return pollset_set_; }
+  grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
-  channelz::SubchannelNode* channelz_node() override;
+  channelz::SubchannelNode* channelz_node();
 
-  const ChannelArgs& args() const override { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
-  std::string address() const override {
+  std::string address() const {
     return grpc_sockaddr_to_uri(&key_.address())
         .value_or("<unknown address type>");
   }
@@ -262,242 +173,33 @@ class OldSubchannel final : public Subchannel {
   // The watcher will be destroyed either when the subchannel is
   // destroyed or when CancelConnectivityStateWatch() is called.
   void WatchConnectivityState(
-      RefCountedPtr<ConnectivityStateWatcherInterface> watcher) override
+      RefCountedPtr<ConnectivityStateWatcherInterface> watcher)
       ABSL_LOCKS_EXCLUDED(mu_);
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
-      override ABSL_LOCKS_EXCLUDED(mu_);
-
-  // Starts a call in the v1 stack.
-  // Returns null if there is no connected subchannel.
-  RefCountedPtr<Call> CreateCall(CreateCallArgs args,
-                                 grpc_error_handle* error) override;
-
-  // Used for calls in the v3 stack.
-  RefCountedPtr<UnstartedCallDestination> call_destination() override;
-
-  // Attempt to connect to the backend.  Has no effect if already connected.
-  void RequestConnection() override ABSL_LOCKS_EXCLUDED(mu_);
-
-  // Resets the connection backoff of the subchannel.
-  void ResetBackoff() override ABSL_LOCKS_EXCLUDED(mu_);
-
-  // Access to data producer map.
-  // We do not hold refs to the data producer; the implementation is
-  // expected to register itself upon construction and remove itself
-  // upon destruction.
-  //
-  // Looks up the current data producer for type and invokes get_or_add()
-  // with a pointer to that producer in the map.  The get_or_add() function
-  // can modify the pointed-to value to update the map.  This provides a
-  // way to either re-use an existing producer or register a new one in
-  // a non-racy way.
-  void GetOrAddDataProducer(
-      UniqueTypeName type,
-      std::function<void(DataProducerInterface**)> get_or_add) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-  // Removes the data producer from the map, if the current producer for
-  // this type is the specified producer.
-  void RemoveDataProducer(DataProducerInterface* data_producer) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine()
-      override {
-    return event_engine_;
-  }
-
-  // Ping API for v3 stack.
-  void Ping(absl::AnyInvocable<void(absl::Status)> on_ack) override;
-  // Ping API for v1 stack.
-  // TODO(roth): Remove this when v3 migration is done.
-  absl::Status Ping(grpc_closure* on_initiate, grpc_closure* on_ack) override;
-
- private:
-  // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
-  // the subchannel's state.
-  class ConnectivityStateWatcherList final {
-   public:
-    explicit ConnectivityStateWatcherList(OldSubchannel* subchannel)
-        : subchannel_(subchannel) {}
-
-    ~ConnectivityStateWatcherList() { Clear(); }
-
-    void AddWatcherLocked(
-        RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
-    void RemoveWatcherLocked(ConnectivityStateWatcherInterface* watcher);
-
-    // Notifies all watchers in the list about a change to state.
-    void NotifyLocked(grpc_connectivity_state state,
-                      const absl::Status& status);
-
-    // Notifies all watchers about a keepalive update.
-    void NotifyOnKeepaliveUpdateLocked(Duration new_keepalive_time);
-
-    void Clear() { watchers_.clear(); }
-
-    bool empty() const { return watchers_.empty(); }
-
-    uint32_t GetMaxConnectionsPerSubchannel() const;
-
-   private:
-    OldSubchannel* subchannel_;
-    absl::flat_hash_set<RefCountedPtr<ConnectivityStateWatcherInterface>,
-                        RefCountedPtrHash<ConnectivityStateWatcherInterface>,
-                        RefCountedPtrEq<ConnectivityStateWatcherInterface>>
-        watchers_;
-  };
-
-  // A ConnectedSubchannel represents a connection.
-  // There are concrete subclasses for the v1 and v3 stacks.
-  class ConnectedSubchannel;
-  class LegacyConnectedSubchannel;
-  class NewConnectedSubchannel;
-
-  class ConnectedSubchannelStateWatcher;
-
-  // Tears down any existing connection, and arranges for destruction
-  void Orphaned() override ABSL_LOCKS_EXCLUDED(mu_);
-
-  RefCountedPtr<ConnectedSubchannel> GetConnectedSubchannel();
-
-  // Sets the subchannel's connectivity state to \a state.
-  void SetConnectivityStateLocked(grpc_connectivity_state state,
-                                  const absl::Status& status)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  void ThrottleKeepaliveTimeLocked(Duration new_keepalive_time)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  // Methods for connection.
-  void OnRetryTimer() ABSL_LOCKS_EXCLUDED(mu_);
-  void OnRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  void StartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnConnectingFinished(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
-  void OnConnectingFinishedLocked(grpc_error_handle error)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  bool PublishTransportLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  // The subchannel pool this subchannel is in.
-  RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
-  // Subchannel key that identifies this subchannel in the subchannel pool.
-  const SubchannelKey key_;
-  // boolean value that identifies this subchannel is created from event engine
-  // endpoint.
-  const bool created_from_endpoint_;
-  // Actual address to connect to.  May be different than the address in
-  // key_ if overridden by proxy mapper.
-  grpc_resolved_address address_for_connect_;
-  // Channel args.
-  ChannelArgs args_;
-  // pollset_set tracking who's interested in a connection being setup.
-  grpc_pollset_set* pollset_set_;
-  // Channelz tracking.
-  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
-  // Minimum connection timeout.
-  Duration min_connect_timeout_;
-
-  // Connection state.
-  OrphanablePtr<SubchannelConnector> connector_;
-  SubchannelConnector::Result connecting_result_;
-  grpc_closure on_connecting_finished_;
-
-  // Protects the other members.
-  Mutex mu_;
-
-  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
-
-  // Connectivity state tracking.
-  // Note that the connectivity state implies the state of the
-  // Subchannel object:
-  // - IDLE: no retry timer pending, can start a connection attempt at any time
-  // - CONNECTING: connection attempt in progress
-  // - READY: connection attempt succeeded, connected_subchannel_ created
-  // - TRANSIENT_FAILURE: connection attempt failed, retry timer pending
-  grpc_connectivity_state state_ ABSL_GUARDED_BY(mu_) = GRPC_CHANNEL_IDLE;
-  absl::Status status_ ABSL_GUARDED_BY(mu_);
-  // The list of connectivity state watchers.
-  ConnectivityStateWatcherList watcher_list_ ABSL_GUARDED_BY(mu_);
-  // Used for sending connectivity state notifications.
-  WorkSerializer work_serializer_;
-
-  // Active connection, or null.
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
-
-  // Backoff state.
-  BackOff backoff_ ABSL_GUARDED_BY(mu_);
-  Timestamp next_attempt_time_ ABSL_GUARDED_BY(mu_);
-  grpc_event_engine::experimental::EventEngine::TaskHandle retry_timer_handle_
-      ABSL_GUARDED_BY(mu_);
-
-  // Keepalive time period
-  Duration keepalive_time_ ABSL_GUARDED_BY(mu_);
-
-  // Data producer map.
-  std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_
-      ABSL_GUARDED_BY(mu_);
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
-};
-
-class NewSubchannel final : public Subchannel {
- public:
-  // Creates a subchannel.
-  static RefCountedPtr<Subchannel> Create(
-      OrphanablePtr<SubchannelConnector> connector,
-      const grpc_resolved_address& address, const ChannelArgs& args);
-
-  // The ctor and dtor are not intended to use directly.
-  NewSubchannel(SubchannelKey key, OrphanablePtr<SubchannelConnector> connector,
-                const ChannelArgs& args);
-  ~NewSubchannel() override;
-
-  // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
-  // is larger than the subchannel's current keepalive time. The updated value
-  // will have an affect when the subchannel creates a new ConnectedSubchannel.
-  void ThrottleKeepaliveTime(Duration new_keepalive_time) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-
-  grpc_pollset_set* pollset_set() const override { return pollset_set_; }
-
-  channelz::SubchannelNode* channelz_node() override;
-
-  const ChannelArgs& args() const override { return args_; }
-
-  std::string address() const override {
-    return grpc_sockaddr_to_uri(&key_.address())
-        .value_or("<unknown address type>");
-  }
-
-  // Starts watching the subchannel's connectivity state.
-  // The first callback to the watcher will be delivered ~immediately.
-  // Subsequent callbacks will be delivered as the subchannel's state
-  // changes.
-  // The watcher will be destroyed either when the subchannel is
-  // destroyed or when CancelConnectivityStateWatch() is called.
-  void WatchConnectivityState(
-      RefCountedPtr<ConnectivityStateWatcherInterface> watcher) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-
-  // Cancels a connectivity state watch.
-  // If the watcher has already been destroyed, this is a no-op.
-  void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
-      override ABSL_LOCKS_EXCLUDED(mu_);
 
   // Starts a call in the v1 stack.
   // Returns null if there is no connected subchannel.
-  RefCountedPtr<Call> CreateCall(CreateCallArgs args,
-                                 grpc_error_handle* error) override;
+  struct CreateCallArgs {
+    grpc_polling_entity* pollent;
+    gpr_cycle_counter start_time;
+    Timestamp deadline;
+    Arena* arena;
+    CallCombiner* call_combiner;
+  };
+  RefCountedPtr<Call> CreateCall(CreateCallArgs args, grpc_error_handle* error);
 
   // Used for calls in the v3 stack.
-  RefCountedPtr<UnstartedCallDestination> call_destination() override;
+  RefCountedPtr<UnstartedCallDestination> call_destination();
 
   // Attempt to connect to the backend.  Has no effect if already connected.
-  void RequestConnection() override ABSL_LOCKS_EXCLUDED(mu_);
+  void RequestConnection() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Resets the connection backoff of the subchannel.
-  void ResetBackoff() override ABSL_LOCKS_EXCLUDED(mu_);
+  void ResetBackoff() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Access to data producer map.
   // We do not hold refs to the data producer; the implementation is
@@ -511,30 +213,35 @@ class NewSubchannel final : public Subchannel {
   // a non-racy way.
   void GetOrAddDataProducer(
       UniqueTypeName type,
-      std::function<void(DataProducerInterface**)> get_or_add) override
+      std::function<void(DataProducerInterface**)> get_or_add)
       ABSL_LOCKS_EXCLUDED(mu_);
   // Removes the data producer from the map, if the current producer for
   // this type is the specified producer.
-  void RemoveDataProducer(DataProducerInterface* data_producer) override
+  void RemoveDataProducer(DataProducerInterface* data_producer)
       ABSL_LOCKS_EXCLUDED(mu_);
 
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine()
-      override {
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine() {
     return event_engine_;
   }
 
   // Ping API for v3 stack.
-  void Ping(absl::AnyInvocable<void(absl::Status)> on_ack) override;
+  void Ping(absl::AnyInvocable<void(absl::Status)> on_ack);
   // Ping API for v1 stack.
   // TODO(roth): Remove this when v3 migration is done.
-  absl::Status Ping(grpc_closure* on_initiate, grpc_closure* on_ack) override;
+  absl::Status Ping(grpc_closure* on_initiate, grpc_closure* on_ack);
+
+  // Exposed for testing purposes only.
+  static ChannelArgs MakeSubchannelArgs(
+      const ChannelArgs& channel_args, const ChannelArgs& address_args,
+      const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
+      const std::string& channel_default_authority);
 
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
   class ConnectivityStateWatcherList final {
    public:
-    explicit ConnectivityStateWatcherList(NewSubchannel* subchannel)
+    explicit ConnectivityStateWatcherList(Subchannel* subchannel)
         : subchannel_(subchannel) {}
 
     ~ConnectivityStateWatcherList() { Clear(); }
@@ -557,7 +264,7 @@ class NewSubchannel final : public Subchannel {
     uint32_t GetMaxConnectionsPerSubchannel() const;
 
    private:
-    NewSubchannel* subchannel_;
+    Subchannel* subchannel_;
     absl::flat_hash_set<RefCountedPtr<ConnectivityStateWatcherInterface>,
                         RefCountedPtrHash<ConnectivityStateWatcherInterface>,
                         RefCountedPtrEq<ConnectivityStateWatcherInterface>>
@@ -681,6 +388,14 @@ class NewSubchannel final : public Subchannel {
   // invalidated as entries are added or removed from the queue (i.e.,
   // std::vector<> would not work).
   std::deque<QueuedCall*> queued_calls_ ABSL_GUARDED_BY(mu_);
+
+  // Metrics and observability.
+  std::shared_ptr<GlobalStatsPluginRegistry::StatsPluginGroup>
+      stats_plugin_group_;
+  absl::string_view target_;
+  absl::string_view backend_service_;
+  absl::string_view locality_;
+  InstrumentStorageRefPtr<SubchannelMetricsDomainAttempts> attempts_storage_;
 };
 
 void TestOnlySetSubchannelAlwaysSendCallsToTransport(bool enabled);

data/src/core/client_channel/subchannel_metrics.cc

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "src/core/client_channel/subchannel_metrics.h"
+
+#include "src/core/telemetry/instrument.h"
+
+namespace grpc_core {
+
+SubchannelMetricsDomainAttempts::CounterHandle
+    SubchannelMetricsDomainAttempts::kConnectionAttemptsSucceeded =
+        SubchannelMetricsDomainAttempts::RegisterCounter(
+            "grpc.subchannel.connection_attempts_succeeded",
+            "Number of successful connection attempts.", "attempt");
+
+SubchannelMetricsDomainAttempts::CounterHandle
+    SubchannelMetricsDomainAttempts::kConnectionAttemptsFailed =
+        SubchannelMetricsDomainAttempts::RegisterCounter(
+            "grpc.subchannel.connection_attempts_failed",
+            "Number of failed connection attempts.", "attempt");
+
+SubchannelMetricsDomainDisconnections::CounterHandle
+    SubchannelMetricsDomainDisconnections::kDisconnections =
+        SubchannelMetricsDomainDisconnections::RegisterCounter(
+            "grpc.subchannel.disconnections",
+            "Number of times the selected subchannel becomes disconnected.",
+            "disconnection");
+
+SubchannelConnectionsDomainOpenConnections::UpDownCounterHandle
+    SubchannelConnectionsDomainOpenConnections::kOpenConnections =
+        SubchannelConnectionsDomainOpenConnections::RegisterUpDownCounter(
+            "grpc.subchannel.open_connections",
+            "Number of open subchannel connections.", "connection");
+
+}  // namespace grpc_core

data/src/core/client_channel/subchannel_metrics.h

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_SUBCHANNEL_METRICS_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_SUBCHANNEL_METRICS_H
+
+#include "src/core/telemetry/instrument.h"
+
+namespace grpc_core {
+
+class SubchannelMetricsDomainAttempts final
+    : public InstrumentDomain<SubchannelMetricsDomainAttempts> {
+ public:
+  using Backend = LowContentionBackend;
+  static constexpr absl::string_view kName = "subchannel";
+  GRPC_INSTRUMENT_DOMAIN_LABELS("grpc.target", "grpc.lb.backend_service",
+                                "grpc.lb.locality");
+
+  static CounterHandle kConnectionAttemptsSucceeded;
+  static CounterHandle kConnectionAttemptsFailed;
+};
+
+class SubchannelMetricsDomainDisconnections final
+    : public InstrumentDomain<SubchannelMetricsDomainDisconnections> {
+ public:
+  using Backend = LowContentionBackend;
+  static constexpr absl::string_view kName = "subchannel";
+  GRPC_INSTRUMENT_DOMAIN_LABELS("grpc.target", "grpc.lb.backend_service",
+                                "grpc.lb.locality", "grpc.disconnect_error");
+
+  static CounterHandle kDisconnections;
+};
+
+class SubchannelConnectionsDomainOpenConnections final
+    : public InstrumentDomain<SubchannelConnectionsDomainOpenConnections> {
+ public:
+  using Backend = LowContentionBackend;
+  static constexpr absl::string_view kName = "subchannel";
+  GRPC_INSTRUMENT_DOMAIN_LABELS("grpc.target", "grpc.security_level",
+                                "grpc.lb.backend_service", "grpc.lb.locality");
+
+  static UpDownCounterHandle kOpenConnections;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_SUBCHANNEL_METRICS_H

data/src/core/client_channel/subchannel_stream_client.cc

@@ -90,7 +90,7 @@ void SubchannelStreamClient::Orphan() {
               << ": SubchannelStreamClient shutting down";
   }
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     event_handler_.reset();
     call_state_.reset();
     if (retry_timer_handle_.has_value()) {
@@ -102,7 +102,7 @@ void SubchannelStreamClient::Orphan() {
 }
 
 void SubchannelStreamClient::StartCall() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   StartCallLocked();
 }
 
@@ -150,7 +150,7 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
 }
 
 void SubchannelStreamClient::OnRetryTimer() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (event_handler_ != nullptr && retry_timer_handle_.has_value() &&
       call_state_ == nullptr) {
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
@@ -353,7 +353,7 @@ void SubchannelStreamClient::CallState::RecvMessageReady() {
   }
   // Report payload.
   {
-    MutexLock lock(&subchannel_stream_client_->mu_);
+    MutexLock lock(subchannel_stream_client_->mu_);
     if (subchannel_stream_client_->event_handler_ != nullptr) {
       absl::Status status =
           subchannel_stream_client_->event_handler_->RecvMessageReadyLocked(
@@ -418,7 +418,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   // that it lives long enough for us to release the mutex, since the
   // call to CallEndedLocked() may release the last ref.
   auto subchannel_stream_client = self->subchannel_stream_client_->Ref();
-  MutexLock lock(&self->subchannel_stream_client_->mu_);
+  MutexLock lock(self->subchannel_stream_client_->mu_);
   if (self->subchannel_stream_client_->event_handler_ != nullptr) {
     self->subchannel_stream_client_->event_handler_
         ->RecvTrailingMetadataReadyLocked(self->subchannel_stream_client_.get(),

data/src/core/{resolver/dns/dns_resolver_plugin.h → config/experiment_env_var.cc}

@@ -1,4 +1,4 @@
-// Copyright 2022 The gRPC Authors
+// Copyright 2026 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,17 +11,20 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
-#define GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
-#include <grpc/support/port_platform.h>
 
-#include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
+
+#include "src/core/util/env.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
-// Centralized decision logic about which client channel DNS resolver to enable.
-void RegisterDnsResolver(CoreConfiguration::Builder* builder);
+bool IsExperimentEnvVarEnabled(const char* name, bool default_value) {
+  auto value = GetEnv(name);
+  if (!value.has_value()) return default_value;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
 
 }  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H

data/src/core/config/experiment_env_var.h

@@ -0,0 +1,26 @@
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_CONFIG_EXPERIMENT_ENV_VAR_H
+#define GRPC_SRC_CORE_CONFIG_EXPERIMENT_ENV_VAR_H
+
+namespace grpc_core {
+
+// Returns true if the specified experiment env var is enabled.
+// If the env var is not set, returns default_value.
+bool IsExperimentEnvVarEnabled(const char* name, bool default_value = false);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CONFIG_EXPERIMENT_ENV_VAR_H