grpc 1.83.1 → 1.84.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/credentials/call/external/file_external_account_credentials.cc

@@ -53,7 +53,7 @@ FileExternalAccountCredentials::FileFetchBody::FileFetchBody(
 void FileExternalAccountCredentials::FileFetchBody::ReadFile() {
   // To retrieve the subject token, we read the file every time we make a
   // request because it may have changed since the last request.
-  auto content_slice = LoadFile(creds_->file_, /*add_null_terminator=*/false);
+  auto content_slice = LoadFile(creds_->file_);
   if (!content_slice.ok()) {
     Finish(absl::UnavailableError(content_slice.status().message()));
     return;

data/src/core/credentials/call/external/url_external_account_credentials.cc

@@ -149,9 +149,8 @@ UrlExternalAccountCredentials::RetrieveSubjectToken(
       URI::Create(url_.scheme(), url_.user_info(), url_.host_port(),
                   url_full_path_, {} /* query params */, "" /* fragment */);
   if (!url_for_request.ok()) {
-    return MakeOrphanable<NoOpFetchBody>(
-        event_engine(), std::move(on_done),
-        absl_status_to_grpc_error(url_for_request.status()));
+    return MakeOrphanable<NoOpFetchBody>(event_engine(), std::move(on_done),
+                                         url_for_request.status());
   }
   return MakeOrphanable<HttpFetchBody>(
       [&](grpc_http_response* response, grpc_closure* on_http_response) {

data/src/core/credentials/call/gcp_service_account_identity/gcp_service_account_identity_credentials.cc

@@ -37,30 +37,14 @@ namespace grpc_core {
 // JwtTokenFetcherCallCredentials
 //
 
-OrphanablePtr<TokenFetcherCredentials::FetchRequest>
-JwtTokenFetcherCallCredentials::FetchToken(
-    Timestamp deadline,
-    absl::AnyInvocable<
-        void(absl::StatusOr<RefCountedPtr<TokenFetcherCredentials::Token>>)>
-        on_done) {
-  return MakeOrphanable<HttpTokenFetcherCredentials::HttpFetchRequest>(
-      this, deadline,
-      [on_done = std::move(on_done)](
-          absl::StatusOr<grpc_http_response> response) mutable {
-        if (!response.ok()) {
-          on_done(response.status());
-          return;
-        }
-        absl::string_view body(response->body, response->body_length);
-        auto expiration_time = GetJwtExpirationTime(body);
-        if (!expiration_time.ok()) {
-          on_done(expiration_time.status());
-          return;
-        }
-        on_done(MakeRefCounted<Token>(
-            Slice::FromCopiedString(absl::StrCat("Bearer ", body)),
-            *expiration_time));
-      });
+absl::StatusOr<RefCountedPtr<TokenFetcherCredentials::Token>>
+JwtTokenFetcherCallCredentials::ExtractToken(
+    const grpc_http_response& response) {
+  absl::string_view body(response.body, response.body_length);
+  auto expiration_time = GetJwtExpirationTime(body);
+  if (!expiration_time.ok()) return expiration_time.status();
+  return MakeRefCounted<Token>(
+      Slice::FromCopiedString(absl::StrCat("Bearer ", body)), *expiration_time);
 }
 
 //

data/src/core/credentials/call/gcp_service_account_identity/gcp_service_account_identity_credentials.h

@@ -42,16 +42,13 @@ namespace grpc_core {
 // Subclasses must implement StartHttpRequest().
 class JwtTokenFetcherCallCredentials : public HttpTokenFetcherCredentials {
  public:
-  OrphanablePtr<FetchRequest> FetchToken(
-      Timestamp deadline,
-      absl::AnyInvocable<
-          void(absl::StatusOr<RefCountedPtr<TokenFetcherCredentials::Token>>)>
-          on_done) final;
+  absl::StatusOr<RefCountedPtr<Token>> ExtractToken(
+      const grpc_http_response& response) final;
 };
 
 // GCP service account identity call credentials.
 // See gRFC A83 (https://github.com/grpc/proposal/pull/438).
-class GcpServiceAccountIdentityCallCredentials
+class GcpServiceAccountIdentityCallCredentials final
     : public JwtTokenFetcherCallCredentials {
  public:
   explicit GcpServiceAccountIdentityCallCredentials(absl::string_view audience)