grpc 1.27.0 → 1.28.0.pre2

data/src/core/ext/filters/client_channel/xds/xds_client.h

@@ -56,7 +56,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
    public:
     virtual ~ClusterWatcherInterface() = default;
 
-    virtual void OnClusterChanged(CdsUpdate cluster_data) = 0;
+    virtual void OnClusterChanged(XdsApi::CdsUpdate cluster_data) = 0;
 
     virtual void OnError(grpc_error* error) = 0;
   };
@@ -66,7 +66,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
    public:
     virtual ~EndpointWatcherInterface() = default;
 
-    virtual void OnEndpointChanged(EdsUpdate update) = 0;
+    virtual void OnEndpointChanged(XdsApi::EdsUpdate update) = 0;
 
     virtual void OnError(grpc_error* error) = 0;
   };
@@ -101,11 +101,25 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
   void CancelEndpointDataWatch(StringView eds_service_name,
                                EndpointWatcherInterface* watcher);
 
-  // Adds and removes client stats for \a cluster_name.
-  void AddClientStats(StringView /*lrs_server*/, StringView cluster_name,
-                      XdsClientStats* client_stats);
-  void RemoveClientStats(StringView /*lrs_server*/, StringView cluster_name,
-                         XdsClientStats* client_stats);
+  // Adds and removes drop stats for cluster_name and eds_service_name.
+  RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
+      StringView lrs_server, StringView cluster_name,
+      StringView eds_service_name);
+  void RemoveClusterDropStats(StringView /*lrs_server*/,
+                              StringView cluster_name,
+                              StringView eds_service_name,
+                              XdsClusterDropStats* cluster_drop_stats);
+
+  // Adds and removes locality stats for cluster_name and eds_service_name
+  // for the specified locality.
+  RefCountedPtr<XdsClusterLocalityStats> AddClusterLocalityStats(
+      StringView lrs_server, StringView cluster_name,
+      StringView eds_service_name, RefCountedPtr<XdsLocalityName> locality);
+  void RemoveClusterLocalityStats(
+      StringView /*lrs_server*/, StringView cluster_name,
+      StringView eds_service_name,
+      const RefCountedPtr<XdsLocalityName>& locality,
+      XdsClusterLocalityStats* cluster_locality_stats);
 
   // Resets connection backoff state.
   void ResetBackoff();
@@ -116,8 +130,6 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
       const grpc_channel_args& args);
 
  private:
-  static const grpc_arg_pointer_vtable kXdsClientVtable;
-
   // Contains a channel to the xds server and all the data related to the
   // channel.  Holds a ref to the xds client object.
   // TODO(roth): This is separate from the XdsClient object because it was
@@ -136,8 +148,7 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     class AdsCallState;
     class LrsCallState;
 
-    ChannelState(RefCountedPtr<XdsClient> xds_client,
-                 const grpc_channel_args& args);
+    ChannelState(RefCountedPtr<XdsClient> xds_client, grpc_channel* channel);
     ~ChannelState();
 
     void Orphan() override;
@@ -155,8 +166,8 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     void StartConnectivityWatchLocked();
     void CancelConnectivityWatchLocked();
 
-    void OnResourceNamesChanged(const std::string& type_url);
-    void OnWatcherRemoved();
+    void Subscribe(const std::string& type_url, const std::string& name);
+    void Unsubscribe(const std::string& type_url, const std::string& name);
 
    private:
     class StateWatcher;
@@ -178,58 +189,67 @@ class XdsClient : public InternallyRefCounted<XdsClient> {
     std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
         watchers;
     // The latest data seen from CDS.
-    Optional<CdsUpdate> update;
+    Optional<XdsApi::CdsUpdate> update;
   };
 
   struct EndpointState {
     std::map<EndpointWatcherInterface*,
              std::unique_ptr<EndpointWatcherInterface>>
         watchers;
-    std::set<XdsClientStats*> client_stats;
     // The latest data seen from EDS.
-    EdsUpdate update;
+    XdsApi::EdsUpdate update;
+  };
+
+  struct LoadReportState {
+    std::set<XdsClusterDropStats*> drop_stats;
+    std::map<RefCountedPtr<XdsLocalityName>, std::set<XdsClusterLocalityStats*>,
+             XdsLocalityName::Less>
+        locality_stats;
+    grpc_millis last_report_time = ExecCtx::Get()->Now();
   };
 
   // Sends an error notification to all watchers.
   void NotifyOnError(grpc_error* error);
 
-  // TODO(juanlishen): Once we implement LDS support, this can be a
-  // normal method instead of a closure callback.
-  static void NotifyOnServiceConfig(void* arg, grpc_error* error);
+  grpc_error* CreateServiceConfig(
+      const std::string& cluster_name,
+      RefCountedPtr<ServiceConfig>* service_config) const;
 
-  std::set<StringView> WatchedClusterNames() const;
-
-  std::set<StringView> EdsServiceNames() const;
-
-  std::map<StringView, std::set<XdsClientStats*>> ClientStatsMap() const;
+  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot();
 
   // Channel arg vtable functions.
   static void* ChannelArgCopy(void* p);
   static void ChannelArgDestroy(void* p);
   static int ChannelArgCmp(void* p, void* q);
 
-  // All the received clusters are cached, no matter they are watched or not.
-  std::map<StringView /*cluster_name*/, ClusterState, StringLess> cluster_map_;
-  // Only the watched EDS service names are stored.
-  std::map<StringView /*eds_service_name*/, EndpointState, StringLess>
-      endpoint_map_;
+  static const grpc_arg_pointer_vtable kXdsClientVtable;
 
-  grpc_core::UniquePtr<char> build_version_;
+  const grpc_millis request_timeout_;
 
   Combiner* combiner_;
   grpc_pollset_set* interested_parties_;
 
   std::unique_ptr<XdsBootstrap> bootstrap_;
+  XdsApi api_;
+
+  const std::string server_name_;
 
-  std::string server_name_;
   std::unique_ptr<ServiceConfigWatcherInterface> service_config_watcher_;
-  // TODO(juanlishen): Once we implement LDS support, this will no
-  // longer be needed.
-  grpc_closure service_config_notify_;
 
   // The channel for communicating with the xds server.
   OrphanablePtr<ChannelState> chand_;
 
+  std::string route_config_name_;
+  std::string cluster_name_;
+  // All the received clusters are cached, no matter they are watched or not.
+  std::map<std::string /*cluster_name*/, ClusterState> cluster_map_;
+  // Only the watched EDS service names are stored.
+  std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map_;
+  std::map<
+      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
+      LoadReportState>
+      load_report_map_;
+
   bool shutting_down_ = false;
 };
 

data/src/core/ext/filters/client_channel/xds/xds_client_stats.cc

@@ -20,63 +20,75 @@
 
 #include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
 
+#include <string.h>
+
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
-#include <string.h>
+
+#include "src/core/ext/filters/client_channel/xds/xds_client.h"
 
 namespace grpc_core {
 
-namespace {
+//
+// XdsClusterDropStats
+//
 
-template <typename T>
-T GetAndResetCounter(Atomic<T>* from) {
-  return from->Exchange(0, MemoryOrder::RELAXED);
+XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
+                                         StringView lrs_server_name,
+                                         StringView cluster_name,
+                                         StringView eds_service_name)
+    : xds_client_(std::move(xds_client)),
+      lrs_server_name_(lrs_server_name),
+      cluster_name_(cluster_name),
+      eds_service_name_(eds_service_name) {}
+
+XdsClusterDropStats::~XdsClusterDropStats() {
+  xds_client_->RemoveClusterDropStats(lrs_server_name_, cluster_name_,
+                                      eds_service_name_, this);
+  xds_client_.reset(DEBUG_LOCATION, "DropStats");
 }
 
-}  // namespace
-
-//
-// XdsClientStats::LocalityStats::LoadMetric::Snapshot
-//
+XdsClusterDropStats::DroppedRequestsMap
+XdsClusterDropStats::GetSnapshotAndReset() {
+  MutexLock lock(&mu_);
+  return std::move(dropped_requests_);
+}
 
-bool XdsClientStats::LocalityStats::LoadMetric::Snapshot::IsAllZero() const {
-  return total_metric_value == 0 && num_requests_finished_with_metric == 0;
+void XdsClusterDropStats::AddCallDropped(const std::string& category) {
+  MutexLock lock(&mu_);
+  ++dropped_requests_[category];
 }
 
 //
-// XdsClientStats::LocalityStats::LoadMetric
+// XdsClusterLocalityStats
 //
 
-XdsClientStats::LocalityStats::LoadMetric::Snapshot
-XdsClientStats::LocalityStats::LoadMetric::GetSnapshotAndReset() {
-  Snapshot metric = {num_requests_finished_with_metric_, total_metric_value_};
-  num_requests_finished_with_metric_ = 0;
-  total_metric_value_ = 0;
-  return metric;
+XdsClusterLocalityStats::XdsClusterLocalityStats(
+    RefCountedPtr<XdsClient> xds_client, StringView lrs_server_name,
+    StringView cluster_name, StringView eds_service_name,
+    RefCountedPtr<XdsLocalityName> name)
+    : xds_client_(std::move(xds_client)),
+      lrs_server_name_(lrs_server_name),
+      cluster_name_(cluster_name),
+      eds_service_name_(eds_service_name),
+      name_(std::move(name)) {}
+
+XdsClusterLocalityStats::~XdsClusterLocalityStats() {
+  xds_client_->RemoveClusterLocalityStats(lrs_server_name_, cluster_name_,
+                                          eds_service_name_, name_, this);
+  xds_client_.reset(DEBUG_LOCATION, "LocalityStats");
 }
 
-//
-// XdsClientStats::LocalityStats::Snapshot
-//
+namespace {
 
-bool XdsClientStats::LocalityStats::Snapshot::IsAllZero() {
-  if (total_successful_requests != 0 || total_requests_in_progress != 0 ||
-      total_error_requests != 0 || total_issued_requests != 0) {
-    return false;
-  }
-  for (auto& p : load_metric_stats) {
-    const LoadMetric::Snapshot& metric_value = p.second;
-    if (!metric_value.IsAllZero()) return false;
-  }
-  return true;
+uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
+  return from->Exchange(0, MemoryOrder::RELAXED);
 }
 
-//
-// XdsClientStats::LocalityStats
-//
+}  // namespace
 
-XdsClientStats::LocalityStats::Snapshot
-XdsClientStats::LocalityStats::GetSnapshotAndReset() {
+XdsClusterLocalityStats::Snapshot
+XdsClusterLocalityStats::GetSnapshotAndReset() {
   Snapshot snapshot = {
       GetAndResetCounter(&total_successful_requests_),
       // Don't reset total_requests_in_progress because it's not
@@ -84,108 +96,21 @@ XdsClientStats::LocalityStats::GetSnapshotAndReset() {
       total_requests_in_progress_.Load(MemoryOrder::RELAXED),
       GetAndResetCounter(&total_error_requests_),
       GetAndResetCounter(&total_issued_requests_)};
-  {
-    MutexLock lock(&load_metric_stats_mu_);
-    for (auto& p : load_metric_stats_) {
-      const std::string& metric_name = p.first;
-      LoadMetric& metric_value = p.second;
-      snapshot.load_metric_stats.emplace(metric_name,
-                                         metric_value.GetSnapshotAndReset());
-    }
-  }
+  MutexLock lock(&backend_metrics_mu_);
+  snapshot.backend_metrics = std::move(backend_metrics_);
   return snapshot;
 }
 
-void XdsClientStats::LocalityStats::AddCallStarted() {
+void XdsClusterLocalityStats::AddCallStarted() {
   total_issued_requests_.FetchAdd(1, MemoryOrder::RELAXED);
   total_requests_in_progress_.FetchAdd(1, MemoryOrder::RELAXED);
 }
 
-void XdsClientStats::LocalityStats::AddCallFinished(bool fail) {
+void XdsClusterLocalityStats::AddCallFinished(bool fail) {
   Atomic<uint64_t>& to_increment =
       fail ? total_error_requests_ : total_successful_requests_;
   to_increment.FetchAdd(1, MemoryOrder::RELAXED);
   total_requests_in_progress_.FetchAdd(-1, MemoryOrder::ACQ_REL);
 }
 
-//
-// XdsClientStats::Snapshot
-//
-
-bool XdsClientStats::Snapshot::IsAllZero() {
-  for (auto& p : upstream_locality_stats) {
-    if (!p.second.IsAllZero()) return false;
-  }
-  for (auto& p : dropped_requests) {
-    if (p.second != 0) return false;
-  }
-  return total_dropped_requests == 0;
-}
-
-//
-// XdsClientStats
-//
-
-XdsClientStats::Snapshot XdsClientStats::GetSnapshotAndReset() {
-  grpc_millis now = ExecCtx::Get()->Now();
-  // Record total_dropped_requests and reporting interval in the snapshot.
-  Snapshot snapshot;
-  snapshot.total_dropped_requests =
-      GetAndResetCounter(&total_dropped_requests_);
-  snapshot.load_report_interval = now - last_report_time_;
-  // Update last report time.
-  last_report_time_ = now;
-  // Snapshot all the other stats.
-  for (auto& p : upstream_locality_stats_) {
-    snapshot.upstream_locality_stats.emplace(p.first,
-                                             p.second->GetSnapshotAndReset());
-  }
-  {
-    MutexLock lock(&dropped_requests_mu_);
-    // This is a workaround for the case where some compilers cannot build
-    // move-assignment of map with non-copyable but movable key.
-    // https://stackoverflow.com/questions/36475497
-    std::swap(snapshot.dropped_requests, dropped_requests_);
-    dropped_requests_.clear();
-  }
-  return snapshot;
-}
-
-void XdsClientStats::MaybeInitLastReportTime() {
-  if (last_report_time_ == -1) last_report_time_ = ExecCtx::Get()->Now();
-}
-
-RefCountedPtr<XdsClientStats::LocalityStats> XdsClientStats::FindLocalityStats(
-    const RefCountedPtr<XdsLocalityName>& locality_name) {
-  auto iter = upstream_locality_stats_.find(locality_name);
-  if (iter == upstream_locality_stats_.end()) {
-    iter = upstream_locality_stats_
-               .emplace(locality_name, MakeRefCounted<LocalityStats>())
-               .first;
-  }
-  return iter->second;
-}
-
-void XdsClientStats::PruneLocalityStats() {
-  auto iter = upstream_locality_stats_.begin();
-  while (iter != upstream_locality_stats_.end()) {
-    if (iter->second->IsSafeToDelete()) {
-      iter = upstream_locality_stats_.erase(iter);
-    } else {
-      ++iter;
-    }
-  }
-}
-
-void XdsClientStats::AddCallDropped(const std::string& category) {
-  total_dropped_requests_.FetchAdd(1, MemoryOrder::RELAXED);
-  MutexLock lock(&dropped_requests_mu_);
-  auto iter = dropped_requests_.find(category);
-  if (iter == dropped_requests_.end()) {
-    dropped_requests_.emplace(category, 1);
-  } else {
-    ++iter->second;
-  }
-}
-
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/xds/xds_client_stats.h

@@ -33,17 +33,26 @@
 
 namespace grpc_core {
 
+// Forward declaration to avoid circular dependency.
+class XdsClient;
+
+// Locality name.
 class XdsLocalityName : public RefCounted<XdsLocalityName> {
  public:
   struct Less {
-    bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
-                    const RefCountedPtr<XdsLocalityName>& rhs) const {
+    bool operator()(const XdsLocalityName* lhs,
+                    const XdsLocalityName* rhs) const {
       int cmp_result = lhs->region_.compare(rhs->region_);
       if (cmp_result != 0) return cmp_result < 0;
       cmp_result = lhs->zone_.compare(rhs->zone_);
       if (cmp_result != 0) return cmp_result < 0;
       return lhs->sub_zone_.compare(rhs->sub_zone_) < 0;
     }
+
+    bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
+                    const RefCountedPtr<XdsLocalityName>& rhs) const {
+      return (*this)(lhs.get(), rhs.get());
+    }
   };
 
   XdsLocalityName(std::string region, std::string zone, std::string subzone)
@@ -77,148 +86,112 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
   UniquePtr<char> human_readable_string_;
 };
 
-// The stats classes (i.e., XdsClientStats, LocalityStats, and LoadMetric) can
-// be taken a snapshot (and reset) to populate the load report. The snapshots
-// are contained in the respective Snapshot structs. The Snapshot structs have
-// no synchronization. The stats classes use several different synchronization
-// methods. 1. Most of the counters are Atomic<>s for performance. 2. Some of
-// the Map<>s are protected by Mutex if we are not guaranteed that the accesses
-// to them are synchronized by the callers. 3. The Map<>s to which the accesses
-// are already synchronized by the callers do not have additional
-// synchronization here. Note that the Map<>s we mentioned in 2 and 3 refer to
-// the map's tree structure rather than the content in each tree node.
-class XdsClientStats {
+// Drop stats for an xds cluster.
+class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
  public:
-  class LocalityStats : public RefCounted<LocalityStats> {
-   public:
-    class LoadMetric {
-     public:
-      struct Snapshot {
-        bool IsAllZero() const;
-
-        uint64_t num_requests_finished_with_metric;
-        double total_metric_value;
-      };
-
-      // Returns a snapshot of this instance and reset all the accumulative
-      // counters.
-      Snapshot GetSnapshotAndReset();
-
-     private:
-      uint64_t num_requests_finished_with_metric_{0};
-      double total_metric_value_{0};
-    };
-
-    using LoadMetricMap = std::map<std::string, LoadMetric>;
-    using LoadMetricSnapshotMap = std::map<std::string, LoadMetric::Snapshot>;
-
-    struct Snapshot {
-      // TODO(juanlishen): Change this to const method when const_iterator is
-      // added to Map<>.
-      bool IsAllZero();
-
-      uint64_t total_successful_requests;
-      uint64_t total_requests_in_progress;
-      uint64_t total_error_requests;
-      uint64_t total_issued_requests;
-      LoadMetricSnapshotMap load_metric_stats;
-    };
-
-    // Returns a snapshot of this instance and reset all the accumulative
-    // counters.
-    Snapshot GetSnapshotAndReset();
-
-    // Each XdsLb::PickerWrapper holds a ref to the perspective LocalityStats.
-    // If the refcount is 0, there won't be new calls recorded to the
-    // LocalityStats, so the LocalityStats can be safely deleted when all the
-    // in-progress calls have finished.
-    // Only be called from the control plane combiner.
-    void RefByPicker() { picker_refcount_.FetchAdd(1, MemoryOrder::ACQ_REL); }
-    // Might be called from the control plane combiner or the data plane
-    // combiner.
-    // TODO(juanlishen): Once https://github.com/grpc/grpc/pull/19390 is merged,
-    //  this method will also only be invoked in the control plane combiner.
-    //  We may then be able to simplify the LocalityStats' lifetime by making it
-    //  RefCounted<> and populating the protobuf in its dtor.
-    void UnrefByPicker() { picker_refcount_.FetchSub(1, MemoryOrder::ACQ_REL); }
-    // Only be called from the control plane combiner.
-    // The only place where the picker_refcount_ can be increased is
-    // RefByPicker(), which also can only be called from the control plane
-    // combiner. Also, if the picker_refcount_ is 0, total_requests_in_progress_
-    // can't be increased from 0. So it's safe to delete the LocalityStats right
-    // after this method returns true.
-    bool IsSafeToDelete() {
-      return picker_refcount_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0 &&
-             total_requests_in_progress_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0;
+  using DroppedRequestsMap = std::map<std::string /* category */, uint64_t>;
+
+  XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
+                      StringView lrs_server_name, StringView cluster_name,
+                      StringView eds_service_name);
+  ~XdsClusterDropStats();
+
+  // Returns a snapshot of this instance and resets all the counters.
+  DroppedRequestsMap GetSnapshotAndReset();
+
+  void AddCallDropped(const std::string& category);
+
+ private:
+  RefCountedPtr<XdsClient> xds_client_;
+  StringView lrs_server_name_;
+  StringView cluster_name_;
+  StringView eds_service_name_;
+  // Protects dropped_requests_. A mutex is necessary because the length of
+  // dropped_requests_ can be accessed by both the picker (from data plane
+  // mutex) and the load reporting thread (from the control plane combiner).
+  Mutex mu_;
+  DroppedRequestsMap dropped_requests_;
+};
+
+// Locality stats for an xds cluster.
+class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
+ public:
+  struct BackendMetric {
+    uint64_t num_requests_finished_with_metric;
+    double total_metric_value;
+
+    BackendMetric& operator+=(const BackendMetric& other) {
+      num_requests_finished_with_metric +=
+          other.num_requests_finished_with_metric;
+      total_metric_value += other.total_metric_value;
+      return *this;
     }
 
-    void AddCallStarted();
-    void AddCallFinished(bool fail = false);
-
-   private:
-    Atomic<uint64_t> total_successful_requests_{0};
-    Atomic<uint64_t> total_requests_in_progress_{0};
-    // Requests that were issued (not dropped) but failed.
-    Atomic<uint64_t> total_error_requests_{0};
-    Atomic<uint64_t> total_issued_requests_{0};
-    // Protects load_metric_stats_. A mutex is necessary because the length of
-    // load_metric_stats_ can be accessed by both the callback intercepting the
-    // call's recv_trailing_metadata (not from any combiner) and the load
-    // reporting thread (from the control plane combiner).
-    Mutex load_metric_stats_mu_;
-    LoadMetricMap load_metric_stats_;
-    // Can be accessed from either the control plane combiner or the data plane
-    // combiner.
-    Atomic<uint8_t> picker_refcount_{0};
+    bool IsZero() const {
+      return num_requests_finished_with_metric == 0 && total_metric_value == 0;
+    }
   };
 
-  // TODO(juanlishen): The value type of Map<> must be movable in current
-  // implementation. To avoid making LocalityStats movable, we wrap it by
-  // std::unique_ptr<>. We should remove this wrapper if the value type of Map<>
-  // doesn't have to be movable.
-  using LocalityStatsMap =
-      std::map<RefCountedPtr<XdsLocalityName>, RefCountedPtr<LocalityStats>,
-               XdsLocalityName::Less>;
-  using LocalityStatsSnapshotMap =
-      std::map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
-               XdsLocalityName::Less>;
-  using DroppedRequestsMap = std::map<std::string, uint64_t>;
-  using DroppedRequestsSnapshotMap = DroppedRequestsMap;
-
   struct Snapshot {
-    // TODO(juanlishen): Change this to const method when const_iterator is
-    // added to Map<>.
-    bool IsAllZero();
-
-    LocalityStatsSnapshotMap upstream_locality_stats;
-    uint64_t total_dropped_requests;
-    DroppedRequestsSnapshotMap dropped_requests;
-    // The actual load report interval.
-    grpc_millis load_report_interval;
+    uint64_t total_successful_requests;
+    uint64_t total_requests_in_progress;
+    uint64_t total_error_requests;
+    uint64_t total_issued_requests;
+    std::map<std::string, BackendMetric> backend_metrics;
+
+    Snapshot& operator+=(const Snapshot& other) {
+      total_successful_requests += other.total_successful_requests;
+      total_requests_in_progress += other.total_requests_in_progress;
+      total_error_requests += other.total_error_requests;
+      total_issued_requests += other.total_issued_requests;
+      for (const auto& p : other.backend_metrics) {
+        backend_metrics[p.first] += p.second;
+      }
+      return *this;
+    }
+
+    bool IsZero() const {
+      if (total_successful_requests != 0 || total_requests_in_progress != 0 ||
+          total_error_requests != 0 || total_issued_requests != 0) {
+        return false;
+      }
+      for (const auto& p : backend_metrics) {
+        if (!p.second.IsZero()) return false;
+      }
+      return true;
+    }
   };
 
-  // Returns a snapshot of this instance and reset all the accumulative
-  // counters.
+  XdsClusterLocalityStats(RefCountedPtr<XdsClient> xds_client,
+                          StringView lrs_server_name, StringView cluster_name,
+                          StringView eds_service_name,
+                          RefCountedPtr<XdsLocalityName> name);
+  ~XdsClusterLocalityStats();
+
+  // Returns a snapshot of this instance and resets all the counters.
   Snapshot GetSnapshotAndReset();
 
-  void MaybeInitLastReportTime();
-  RefCountedPtr<LocalityStats> FindLocalityStats(
-      const RefCountedPtr<XdsLocalityName>& locality_name);
-  void PruneLocalityStats();
-  void AddCallDropped(const std::string& category);
+  void AddCallStarted();
+  void AddCallFinished(bool fail = false);
 
  private:
-  // The stats for each locality.
-  LocalityStatsMap upstream_locality_stats_;
-  Atomic<uint64_t> total_dropped_requests_{0};
-  // Protects dropped_requests_. A mutex is necessary because the length of
-  // dropped_requests_ can be accessed by both the picker (from data plane
-  // combiner) and the load reporting thread (from the control plane combiner).
-  Mutex dropped_requests_mu_;
-  DroppedRequestsMap dropped_requests_;
-  // The timestamp of last reporting. For the LB-policy-wide first report, the
-  // last_report_time is the time we scheduled the first reporting timer.
-  grpc_millis last_report_time_ = -1;
+  RefCountedPtr<XdsClient> xds_client_;
+  StringView lrs_server_name_;
+  StringView cluster_name_;
+  StringView eds_service_name_;
+  RefCountedPtr<XdsLocalityName> name_;
+
+  Atomic<uint64_t> total_successful_requests_{0};
+  Atomic<uint64_t> total_requests_in_progress_{0};
+  Atomic<uint64_t> total_error_requests_{0};
+  Atomic<uint64_t> total_issued_requests_{0};
+
+  // Protects backend_metrics_. A mutex is necessary because the length of
+  // backend_metrics_ can be accessed by both the callback intercepting the
+  // call's recv_trailing_metadata (not from the control plane combiner) and
+  // the load reporting thread (from the control plane combiner).
+  Mutex backend_metrics_mu_;
+  std::map<std::string, BackendMetric> backend_metrics_;
 };
 
 }  // namespace grpc_core