grpc 1.33.0.pre1 → 1.37.0.pre1

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

@@ -1,32 +1,60 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+// Copyright 2018 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_H
 
 #include <grpc/support/port_platform.h>
 
-/** Channel arg indicating if a target corresponding to the address is a backend
- * received from a balancer. The type of this arg is an integer and the value is
- * treated as a bool. */
-// TODO(roth): Depending on how we ultimately decide to handle fallback,
-// this may no longer be needed.
-#define GRPC_ARG_ADDRESS_IS_BACKEND_FROM_XDS_LOAD_BALANCER \
-  "grpc.address_is_backend_from_xds_load_balancer"
+#include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/ext/xds/xds_client_stats.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+// Defined in the EDS policy.
+extern const char* kXdsLocalityNameAttributeKey;
+
+class XdsLocalityAttribute : public ServerAddress::AttributeInterface {
+ public:
+  explicit XdsLocalityAttribute(RefCountedPtr<XdsLocalityName> locality_name)
+      : locality_name_(std::move(locality_name)) {}
+
+  RefCountedPtr<XdsLocalityName> locality_name() const {
+    return locality_name_;
+  }
+
+  std::unique_ptr<AttributeInterface> Copy() const override {
+    return absl::make_unique<XdsLocalityAttribute>(locality_name_->Ref());
+  }
+
+  int Cmp(const AttributeInterface* other) const override {
+    const auto* other_locality_attr =
+        static_cast<const XdsLocalityAttribute*>(other);
+    return locality_name_->Compare(*other_locality_attr->locality_name_);
+  }
+
+  std::string ToString() const override {
+    return locality_name_->AsHumanReadableString();
+  }
+
+ private:
+  RefCountedPtr<XdsLocalityName> locality_name_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_H */

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h

@@ -0,0 +1,29 @@
+//
+// Copyright 2020 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CHANNEL_ARGS_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CHANNEL_ARGS_H
+
+// Channel arg indicating the xDS cluster name.
+// Set by xds_cluster_impl LB policy and used by GoogleDefaultCredentials.
+#define GRPC_ARG_XDS_CLUSTER_NAME "grpc.internal.xds_cluster_name"
+
+// For testing purpose, this channel arg indicating xds_cluster_resolver LB
+// policy should use the fake DNS resolver to resolve logical dns cluster.
+#define GRPC_ARG_XDS_LOGICAL_DNS_CLUSTER_FAKE_RESOLVER_RESPONSE_GENERATOR \
+  "grpc.internal.xds_logical_dns_cluster_fake_resolver_response_generator"
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CHANNEL_ARGS_H

data/src/core/ext/filters/client_channel/lb_policy/xds/{eds_drop.cc → xds_cluster_impl.cc}

@@ -22,39 +22,109 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/work_serializer.h"
 
 namespace grpc_core {
 
-TraceFlag grpc_eds_drop_lb_trace(false, "eds_drop_lb");
+TraceFlag grpc_xds_cluster_impl_lb_trace(false, "xds_cluster_impl_lb");
 
 namespace {
 
-constexpr char kEdsDrop[] = "eds_drop_experimental";
+//
+// global circuit breaker atomic map
+//
 
-// Config for EDS drop LB policy.
-class EdsDropLbConfig : public LoadBalancingPolicy::Config {
+class CircuitBreakerCallCounterMap {
  public:
-  EdsDropLbConfig(RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
-                  std::string cluster_name, std::string eds_service_name,
-                  absl::optional<std::string> lrs_load_reporting_server_name,
-                  RefCountedPtr<XdsApi::EdsUpdate::DropConfig> drop_config)
+  using Key =
+      std::pair<std::string /*cluster*/, std::string /*eds_service_name*/>;
+
+  class CallCounter : public RefCounted<CallCounter> {
+   public:
+    explicit CallCounter(Key key) : key_(std::move(key)) {}
+    ~CallCounter() override;
+
+    uint32_t Increment() { return concurrent_requests_.FetchAdd(1); }
+    void Decrement() { concurrent_requests_.FetchSub(1); }
+
+   private:
+    Key key_;
+    Atomic<uint32_t> concurrent_requests_{0};
+  };
+
+  RefCountedPtr<CallCounter> GetOrCreate(const std::string& cluster,
+                                         const std::string& eds_service_name);
+
+ private:
+  Mutex mu_;
+  std::map<Key, CallCounter*> map_;
+};
+
+CircuitBreakerCallCounterMap* g_call_counter_map = nullptr;
+
+RefCountedPtr<CircuitBreakerCallCounterMap::CallCounter>
+CircuitBreakerCallCounterMap::GetOrCreate(const std::string& cluster,
+                                          const std::string& eds_service_name) {
+  Key key(cluster, eds_service_name);
+  RefCountedPtr<CallCounter> result;
+  MutexLock lock(&mu_);
+  auto it = map_.find(key);
+  if (it == map_.end()) {
+    it = map_.insert({key, nullptr}).first;
+  } else {
+    result = it->second->RefIfNonZero();
+  }
+  if (result == nullptr) {
+    result = MakeRefCounted<CallCounter>(std::move(key));
+    it->second = result.get();
+  }
+  return result;
+}
+
+CircuitBreakerCallCounterMap::CallCounter::~CallCounter() {
+  MutexLock lock(&g_call_counter_map->mu_);
+  auto it = g_call_counter_map->map_.find(key_);
+  if (it != g_call_counter_map->map_.end() && it->second == this) {
+    g_call_counter_map->map_.erase(it);
+  }
+}
+
+//
+// LB policy
+//
+
+constexpr char kXdsClusterImpl[] = "xds_cluster_impl_experimental";
+
+// Config for xDS Cluster Impl LB policy.
+class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
+ public:
+  XdsClusterImplLbConfig(
+      RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
+      std::string cluster_name, std::string eds_service_name,
+      absl::optional<std::string> lrs_load_reporting_server_name,
+      uint32_t max_concurrent_requests,
+      RefCountedPtr<XdsApi::EdsUpdate::DropConfig> drop_config)
       : child_policy_(std::move(child_policy)),
         cluster_name_(std::move(cluster_name)),
         eds_service_name_(std::move(eds_service_name)),
         lrs_load_reporting_server_name_(
             std::move(lrs_load_reporting_server_name)),
+        max_concurrent_requests_(max_concurrent_requests),
         drop_config_(std::move(drop_config)) {}
 
-  const char* name() const override { return kEdsDrop; }
+  const char* name() const override { return kXdsClusterImpl; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy() const {
     return child_policy_;
@@ -64,6 +134,7 @@ class EdsDropLbConfig : public LoadBalancingPolicy::Config {
   const absl::optional<std::string>& lrs_load_reporting_server_name() const {
     return lrs_load_reporting_server_name_;
   };
+  uint32_t max_concurrent_requests() const { return max_concurrent_requests_; }
   RefCountedPtr<XdsApi::EdsUpdate::DropConfig> drop_config() const {
     return drop_config_;
   }
@@ -73,21 +144,38 @@ class EdsDropLbConfig : public LoadBalancingPolicy::Config {
   std::string cluster_name_;
   std::string eds_service_name_;
   absl::optional<std::string> lrs_load_reporting_server_name_;
+  uint32_t max_concurrent_requests_;
   RefCountedPtr<XdsApi::EdsUpdate::DropConfig> drop_config_;
 };
 
-// EDS Drop LB policy.
-class EdsDropLb : public LoadBalancingPolicy {
+// xDS Cluster Impl LB policy.
+class XdsClusterImplLb : public LoadBalancingPolicy {
  public:
-  EdsDropLb(RefCountedPtr<XdsClient> xds_client, Args args);
+  XdsClusterImplLb(RefCountedPtr<XdsClient> xds_client, Args args);
 
-  const char* name() const override { return kEdsDrop; }
+  const char* name() const override { return kXdsClusterImpl; }
 
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
 
  private:
+  class StatsSubchannelWrapper : public DelegatingSubchannel {
+   public:
+    StatsSubchannelWrapper(
+        RefCountedPtr<SubchannelInterface> wrapped_subchannel,
+        RefCountedPtr<XdsClusterLocalityStats> locality_stats)
+        : DelegatingSubchannel(std::move(wrapped_subchannel)),
+          locality_stats_(std::move(locality_stats)) {}
+
+    XdsClusterLocalityStats* locality_stats() const {
+      return locality_stats_.get();
+    }
+
+   private:
+    RefCountedPtr<XdsClusterLocalityStats> locality_stats_;
+  };
+
   // A simple wrapper for ref-counting a picker from the child policy.
   class RefCountedPicker : public RefCounted<RefCountedPicker> {
    public:
@@ -100,16 +188,16 @@ class EdsDropLb : public LoadBalancingPolicy {
   };
 
   // A picker that wraps the picker from the child to perform drops.
-  class DropPicker : public SubchannelPicker {
+  class Picker : public SubchannelPicker {
    public:
-    DropPicker(EdsDropLb* eds_drop_lb, RefCountedPtr<RefCountedPicker> picker)
-        : drop_config_(eds_drop_lb->config_->drop_config()),
-          drop_stats_(eds_drop_lb->drop_stats_),
-          picker_(std::move(picker)) {}
+    Picker(XdsClusterImplLb* xds_cluster_impl_lb,
+           RefCountedPtr<RefCountedPicker> picker);
 
-    PickResult Pick(PickArgs args);
+    PickResult Pick(PickArgs args) override;
 
    private:
+    RefCountedPtr<CircuitBreakerCallCounterMap::CallCounter> call_counter_;
+    uint32_t max_concurrent_requests_;
     RefCountedPtr<XdsApi::EdsUpdate::DropConfig> drop_config_;
     RefCountedPtr<XdsClusterDropStats> drop_stats_;
     RefCountedPtr<RefCountedPicker> picker_;
@@ -117,10 +205,12 @@ class EdsDropLb : public LoadBalancingPolicy {
 
   class Helper : public ChannelControlHelper {
    public:
-    explicit Helper(RefCountedPtr<EdsDropLb> eds_drop_policy)
-        : eds_drop_policy_(std::move(eds_drop_policy)) {}
+    explicit Helper(RefCountedPtr<XdsClusterImplLb> xds_cluster_impl_policy)
+        : xds_cluster_impl_policy_(std::move(xds_cluster_impl_policy)) {}
 
-    ~Helper() { eds_drop_policy_.reset(DEBUG_LOCATION, "Helper"); }
+    ~Helper() override {
+      xds_cluster_impl_policy_.reset(DEBUG_LOCATION, "Helper");
+    }
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         ServerAddress address, const grpc_channel_args& args) override;
@@ -131,10 +221,10 @@ class EdsDropLb : public LoadBalancingPolicy {
                        absl::string_view message) override;
 
    private:
-    RefCountedPtr<EdsDropLb> eds_drop_policy_;
+    RefCountedPtr<XdsClusterImplLb> xds_cluster_impl_policy_;
   };
 
-  ~EdsDropLb();
+  ~XdsClusterImplLb() override;
 
   void ShutdownLocked() override;
 
@@ -146,7 +236,10 @@ class EdsDropLb : public LoadBalancingPolicy {
   void MaybeUpdatePickerLocked();
 
   // Current config from the resolver.
-  RefCountedPtr<EdsDropLbConfig> config_;
+  RefCountedPtr<XdsClusterImplLbConfig> config_;
+
+  // Current concurrent number of requests.
+  RefCountedPtr<CircuitBreakerCallCounterMap::CallCounter> call_counter_;
 
   // Internal state.
   bool shutting_down_ = false;
@@ -166,12 +259,26 @@ class EdsDropLb : public LoadBalancingPolicy {
 };
 
 //
-// EdsDropLb::DropPicker
+// XdsClusterImplLb::Picker
 //
 
-LoadBalancingPolicy::PickResult EdsDropLb::DropPicker::Pick(
+XdsClusterImplLb::Picker::Picker(XdsClusterImplLb* xds_cluster_impl_lb,
+                                 RefCountedPtr<RefCountedPicker> picker)
+    : call_counter_(xds_cluster_impl_lb->call_counter_),
+      max_concurrent_requests_(
+          xds_cluster_impl_lb->config_->max_concurrent_requests()),
+      drop_config_(xds_cluster_impl_lb->config_->drop_config()),
+      drop_stats_(xds_cluster_impl_lb->drop_stats_),
+      picker_(std::move(picker)) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_cluster_impl_lb %p] constructed new picker %p",
+            xds_cluster_impl_lb, this);
+  }
+}
+
+LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
     LoadBalancingPolicy::PickArgs args) {
-  // Handle drop.
+  // Handle EDS drops.
   const std::string* drop_category;
   if (drop_config_->ShouldDrop(&drop_category)) {
     if (drop_stats_ != nullptr) drop_stats_->AddCallDropped(*drop_category);
@@ -179,41 +286,99 @@ LoadBalancingPolicy::PickResult EdsDropLb::DropPicker::Pick(
     result.type = PickResult::PICK_COMPLETE;
     return result;
   }
+  // Handle circuit breaking.
+  uint32_t current = call_counter_->Increment();
+  // Check and see if we exceeded the max concurrent requests count.
+  if (current >= max_concurrent_requests_) {
+    call_counter_->Decrement();
+    if (drop_stats_ != nullptr) drop_stats_->AddUncategorizedDrops();
+    PickResult result;
+    result.type = PickResult::PICK_COMPLETE;
+    return result;
+  }
   // If we're not dropping the call, we should always have a child picker.
   if (picker_ == nullptr) {  // Should never happen.
     PickResult result;
     result.type = PickResult::PICK_FAILED;
-    result.error =
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                               "eds_drop picker not given any child picker"),
-                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_INTERNAL);
+    result.error = grpc_error_set_int(
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "xds_cluster_impl picker not given any child picker"),
+        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_INTERNAL);
+    call_counter_->Decrement();
     return result;
   }
   // Not dropping, so delegate to child picker.
-  return picker_->Pick(args);
+  PickResult result = picker_->Pick(args);
+  if (result.type == result.PICK_COMPLETE && result.subchannel != nullptr) {
+    XdsClusterLocalityStats* locality_stats = nullptr;
+    if (drop_stats_ != nullptr) {  // If load reporting is enabled.
+      auto* subchannel_wrapper =
+          static_cast<StatsSubchannelWrapper*>(result.subchannel.get());
+      // Handle load reporting.
+      locality_stats = subchannel_wrapper->locality_stats()->Ref().release();
+      // Record a call started.
+      locality_stats->AddCallStarted();
+      // Unwrap subchannel to pass back up the stack.
+      result.subchannel = subchannel_wrapper->wrapped_subchannel();
+    }
+    // Intercept the recv_trailing_metadata op to record call completion.
+    auto* call_counter = call_counter_->Ref(DEBUG_LOCATION, "call").release();
+    auto original_recv_trailing_metadata_ready =
+        result.recv_trailing_metadata_ready;
+    result.recv_trailing_metadata_ready =
+        // Note: This callback does not run in either the control plane
+        // work serializer or in the data plane mutex.
+        [locality_stats, original_recv_trailing_metadata_ready, call_counter](
+            grpc_error* error, MetadataInterface* metadata,
+            CallState* call_state) {
+          // Record call completion for load reporting.
+          if (locality_stats != nullptr) {
+            const bool call_failed = error != GRPC_ERROR_NONE;
+            locality_stats->AddCallFinished(call_failed);
+            locality_stats->Unref(DEBUG_LOCATION, "LocalityStats+call");
+          }
+          // Decrement number of calls in flight.
+          call_counter->Decrement();
+          call_counter->Unref(DEBUG_LOCATION, "call");
+          // Invoke the original recv_trailing_metadata_ready callback, if any.
+          if (original_recv_trailing_metadata_ready != nullptr) {
+            original_recv_trailing_metadata_ready(error, metadata, call_state);
+          }
+        };
+  } else {
+    // TODO(roth): We should ideally also record call failures here in the case
+    // where a pick fails.  This is challenging, because we don't know which
+    // picks are for wait_for_ready RPCs or how many times we'll return a
+    // failure for the same wait_for_ready RPC.
+    call_counter_->Decrement();
+  }
+  return result;
 }
 
 //
-// EdsDropLb
+// XdsClusterImplLb
 //
 
-EdsDropLb::EdsDropLb(RefCountedPtr<XdsClient> xds_client, Args args)
+XdsClusterImplLb::XdsClusterImplLb(RefCountedPtr<XdsClient> xds_client,
+                                   Args args)
     : LoadBalancingPolicy(std::move(args)), xds_client_(std::move(xds_client)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] created -- using xds client %p", this,
-            xds_client_.get());
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_cluster_impl_lb %p] created -- using xds client %p",
+            this, xds_client_.get());
   }
 }
 
-EdsDropLb::~EdsDropLb() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] destroying xds LB policy", this);
+XdsClusterImplLb::~XdsClusterImplLb() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_cluster_impl_lb %p] destroying xds_cluster_impl LB policy",
+            this);
   }
 }
 
-void EdsDropLb::ShutdownLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] shutting down", this);
+void XdsClusterImplLb::ShutdownLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_cluster_impl_lb %p] shutting down", this);
   }
   shutting_down_ = true;
   // Remove the child policy's interested_parties pollset_set from the
@@ -230,50 +395,60 @@ void EdsDropLb::ShutdownLocked() {
   xds_client_.reset();
 }
 
-void EdsDropLb::ExitIdleLocked() {
+void XdsClusterImplLb::ExitIdleLocked() {
   if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
 }
 
-void EdsDropLb::ResetBackoffLocked() {
+void XdsClusterImplLb::ResetBackoffLocked() {
   // The XdsClient will have its backoff reset by the xds resolver, so we
   // don't need to do it here.
   if (child_policy_ != nullptr) child_policy_->ResetBackoffLocked();
 }
 
-void EdsDropLb::UpdateLocked(UpdateArgs args) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] Received update", this);
+void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO, "[xds_cluster_impl_lb %p] Received update", this);
   }
   // Update config.
+  const bool is_initial_update = config_ == nullptr;
   auto old_config = std::move(config_);
   config_ = std::move(args.config);
-  // Update load reporting if needed.
-  if (old_config == nullptr ||
-      config_->lrs_load_reporting_server_name() !=
-          old_config->lrs_load_reporting_server_name() ||
-      config_->cluster_name() != old_config->cluster_name() ||
-      config_->eds_service_name() != old_config->eds_service_name()) {
-    drop_stats_.reset();
+  // On initial update, create drop stats.
+  if (is_initial_update) {
     if (config_->lrs_load_reporting_server_name().has_value()) {
       drop_stats_ = xds_client_->AddClusterDropStats(
           config_->lrs_load_reporting_server_name().value(),
           config_->cluster_name(), config_->eds_service_name());
     }
+    call_counter_ = g_call_counter_map->GetOrCreate(
+        config_->cluster_name(), config_->eds_service_name());
+  } else {
+    // Cluster name, EDS service name, and LRS server name should never
+    // change, because the EDS policy above us should be swapped out if
+    // that happens.
+    GPR_ASSERT(config_->cluster_name() == old_config->cluster_name());
+    GPR_ASSERT(config_->eds_service_name() == old_config->eds_service_name());
+    GPR_ASSERT(config_->lrs_load_reporting_server_name() ==
+               old_config->lrs_load_reporting_server_name());
+  }
+  // Update picker if max_concurrent_requests has changed.
+  if (is_initial_update || config_->max_concurrent_requests() !=
+                               old_config->max_concurrent_requests()) {
     MaybeUpdatePickerLocked();
   }
   // Update child policy.
   UpdateChildPolicyLocked(std::move(args.addresses), args.args);
-  args.args = nullptr;
 }
 
-void EdsDropLb::MaybeUpdatePickerLocked() {
+void XdsClusterImplLb::MaybeUpdatePickerLocked() {
   // If we're dropping all calls, report READY, regardless of what (or
   // whether) the child has reported.
   if (config_->drop_config() != nullptr && config_->drop_config()->drop_all()) {
-    auto drop_picker = absl::make_unique<DropPicker>(this, picker_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
+    auto drop_picker = absl::make_unique<Picker>(this, picker_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
       gpr_log(GPR_INFO,
-              "[eds_drop_lb %p] updating connectivity (drop all): state=READY "
+              "[xds_cluster_impl_lb %p] updating connectivity (drop all): "
+              "state=READY "
               "picker=%p",
               this, drop_picker.get());
     }
@@ -283,10 +458,11 @@ void EdsDropLb::MaybeUpdatePickerLocked() {
   }
   // Otherwise, update only if we have a child picker.
   if (picker_ != nullptr) {
-    auto drop_picker = absl::make_unique<DropPicker>(this, picker_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
+    auto drop_picker = absl::make_unique<Picker>(this, picker_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
       gpr_log(GPR_INFO,
-              "[eds_drop_lb %p] updating connectivity: state=%s status=(%s) "
+              "[xds_cluster_impl_lb %p] updating connectivity: state=%s "
+              "status=(%s) "
               "picker=%p",
               this, ConnectivityStateName(state_), status_.ToString().c_str(),
               drop_picker.get());
@@ -296,7 +472,7 @@ void EdsDropLb::MaybeUpdatePickerLocked() {
   }
 }
 
-OrphanablePtr<LoadBalancingPolicy> EdsDropLb::CreateChildPolicyLocked(
+OrphanablePtr<LoadBalancingPolicy> XdsClusterImplLb::CreateChildPolicyLocked(
     const grpc_channel_args* args) {
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
@@ -305,9 +481,10 @@ OrphanablePtr<LoadBalancingPolicy> EdsDropLb::CreateChildPolicyLocked(
       absl::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
-                                         &grpc_eds_drop_lb_trace);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] Created new child policy handler %p",
+                                         &grpc_xds_cluster_impl_lb_trace);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_cluster_impl_lb %p] Created new child policy handler %p",
             this, lb_policy.get());
   }
   // Add our interested_parties pollset_set to that of the newly created
@@ -318,8 +495,8 @@ OrphanablePtr<LoadBalancingPolicy> EdsDropLb::CreateChildPolicyLocked(
   return lb_policy;
 }
 
-void EdsDropLb::UpdateChildPolicyLocked(ServerAddressList addresses,
-                                        const grpc_channel_args* args) {
+void XdsClusterImplLb::UpdateChildPolicyLocked(ServerAddressList addresses,
+                                               const grpc_channel_args* args) {
   // Create policy if needed.
   if (child_policy_ == nullptr) {
     child_policy_ = CreateChildPolicyLocked(args);
@@ -328,78 +505,110 @@ void EdsDropLb::UpdateChildPolicyLocked(ServerAddressList addresses,
   UpdateArgs update_args;
   update_args.addresses = std::move(addresses);
   update_args.config = config_->child_policy();
-  update_args.args = args;
+  grpc_arg cluster_arg = grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_XDS_CLUSTER_NAME),
+      const_cast<char*>(config_->cluster_name().c_str()));
+  update_args.args = grpc_channel_args_copy_and_add(args, &cluster_arg, 1);
   // Update the policy.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
-    gpr_log(GPR_INFO, "[eds_drop_lb %p] Updating child policy handler %p", this,
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_cluster_impl_lb %p] Updating child policy handler %p", this,
             child_policy_.get());
   }
   child_policy_->UpdateLocked(std::move(update_args));
 }
 
 //
-// EdsDropLb::Helper
+// XdsClusterImplLb::Helper
 //
 
-RefCountedPtr<SubchannelInterface> EdsDropLb::Helper::CreateSubchannel(
+RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
     ServerAddress address, const grpc_channel_args& args) {
-  if (eds_drop_policy_->shutting_down_) return nullptr;
-  return eds_drop_policy_->channel_control_helper()->CreateSubchannel(
+  if (xds_cluster_impl_policy_->shutting_down_) return nullptr;
+  // If load reporting is enabled, wrap the subchannel such that it
+  // includes the locality stats object, which will be used by the EdsPicker.
+  if (xds_cluster_impl_policy_->config_->lrs_load_reporting_server_name()
+          .has_value()) {
+    RefCountedPtr<XdsLocalityName> locality_name;
+    auto* attribute = address.GetAttribute(kXdsLocalityNameAttributeKey);
+    if (attribute != nullptr) {
+      const auto* locality_attr =
+          static_cast<const XdsLocalityAttribute*>(attribute);
+      locality_name = locality_attr->locality_name();
+    }
+    RefCountedPtr<XdsClusterLocalityStats> locality_stats =
+        xds_cluster_impl_policy_->xds_client_->AddClusterLocalityStats(
+            *xds_cluster_impl_policy_->config_
+                 ->lrs_load_reporting_server_name(),
+            xds_cluster_impl_policy_->config_->cluster_name(),
+            xds_cluster_impl_policy_->config_->eds_service_name(),
+            std::move(locality_name));
+    return MakeRefCounted<StatsSubchannelWrapper>(
+        xds_cluster_impl_policy_->channel_control_helper()->CreateSubchannel(
+            std::move(address), args),
+        std::move(locality_stats));
+  }
+  // Load reporting not enabled, so don't wrap the subchannel.
+  return xds_cluster_impl_policy_->channel_control_helper()->CreateSubchannel(
       std::move(address), args);
 }
 
-void EdsDropLb::Helper::UpdateState(grpc_connectivity_state state,
-                                    const absl::Status& status,
-                                    std::unique_ptr<SubchannelPicker> picker) {
-  if (eds_drop_policy_->shutting_down_) return;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_eds_drop_lb_trace)) {
+void XdsClusterImplLb::Helper::UpdateState(
+    grpc_connectivity_state state, const absl::Status& status,
+    std::unique_ptr<SubchannelPicker> picker) {
+  if (xds_cluster_impl_policy_->shutting_down_) return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
     gpr_log(GPR_INFO,
-            "[eds_drop_lb %p] child connectivity state update: state=%s (%s) "
+            "[xds_cluster_impl_lb %p] child connectivity state update: "
+            "state=%s (%s) "
             "picker=%p",
-            eds_drop_policy_.get(), ConnectivityStateName(state),
+            xds_cluster_impl_policy_.get(), ConnectivityStateName(state),
             status.ToString().c_str(), picker.get());
   }
   // Save the state and picker.
-  eds_drop_policy_->state_ = state;
-  eds_drop_policy_->status_ = status;
-  eds_drop_policy_->picker_ =
+  xds_cluster_impl_policy_->state_ = state;
+  xds_cluster_impl_policy_->status_ = status;
+  xds_cluster_impl_policy_->picker_ =
       MakeRefCounted<RefCountedPicker>(std::move(picker));
   // Wrap the picker and return it to the channel.
-  eds_drop_policy_->MaybeUpdatePickerLocked();
+  xds_cluster_impl_policy_->MaybeUpdatePickerLocked();
 }
 
-void EdsDropLb::Helper::RequestReresolution() {
-  if (eds_drop_policy_->shutting_down_) return;
-  eds_drop_policy_->channel_control_helper()->RequestReresolution();
+void XdsClusterImplLb::Helper::RequestReresolution() {
+  if (xds_cluster_impl_policy_->shutting_down_) return;
+  xds_cluster_impl_policy_->channel_control_helper()->RequestReresolution();
 }
 
-void EdsDropLb::Helper::AddTraceEvent(TraceSeverity severity,
-                                      absl::string_view message) {
-  if (eds_drop_policy_->shutting_down_) return;
-  eds_drop_policy_->channel_control_helper()->AddTraceEvent(severity, message);
+void XdsClusterImplLb::Helper::AddTraceEvent(TraceSeverity severity,
+                                             absl::string_view message) {
+  if (xds_cluster_impl_policy_->shutting_down_) return;
+  xds_cluster_impl_policy_->channel_control_helper()->AddTraceEvent(severity,
+                                                                    message);
 }
 
 //
 // factory
 //
 
-class EdsDropLbFactory : public LoadBalancingPolicyFactory {
+class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
     grpc_error* error = GRPC_ERROR_NONE;
     RefCountedPtr<XdsClient> xds_client = XdsClient::GetOrCreate(&error);
     if (error != GRPC_ERROR_NONE) {
-      gpr_log(GPR_ERROR,
-              "cannot get XdsClient to instantiate eds_drop LB policy: %s",
-              grpc_error_string(error));
+      gpr_log(
+          GPR_ERROR,
+          "cannot get XdsClient to instantiate xds_cluster_impl LB policy: %s",
+          grpc_error_string(error));
       GRPC_ERROR_UNREF(error);
       return nullptr;
     }
-    return MakeOrphanable<EdsDropLb>(std::move(xds_client), std::move(args));
+    return MakeOrphanable<XdsClusterImplLb>(std::move(xds_client),
+                                            std::move(args));
   }
 
-  const char* name() const override { return kEdsDrop; }
+  const char* name() const override { return kXdsClusterImpl; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error** error) const override {
@@ -408,7 +617,7 @@ class EdsDropLbFactory : public LoadBalancingPolicyFactory {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:loadBalancingPolicy error:eds_drop policy requires "
+          "field:loadBalancingPolicy error:xds_cluster_impl policy requires "
           "configuration. Please use loadBalancingConfig field of service "
           "config instead.");
       return nullptr;
@@ -466,6 +675,18 @@ class EdsDropLbFactory : public LoadBalancingPolicyFactory {
         lrs_load_reporting_server_name = it->second.string_value();
       }
     }
+    // Max concurrent requests.
+    uint32_t max_concurrent_requests = 1024;
+    it = json.object_value().find("maxConcurrentRequests");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::NUMBER) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:max_concurrent_requests error:must be of type number"));
+      } else {
+        max_concurrent_requests =
+            gpr_parse_nonnegative_int(it->second.string_value().c_str());
+      }
+    }
     // Drop config.
     auto drop_config = MakeRefCounted<XdsApi::EdsUpdate::DropConfig>();
     it = json.object_value().find("dropCategories");
@@ -482,13 +703,13 @@ class EdsDropLbFactory : public LoadBalancingPolicyFactory {
     }
     if (!error_list.empty()) {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-          "eds_drop_experimental LB policy config", &error_list);
+          "xds_cluster_impl_experimental LB policy config", &error_list);
       return nullptr;
     }
-    return MakeRefCounted<EdsDropLbConfig>(
+    return MakeRefCounted<XdsClusterImplLbConfig>(
         std::move(child_policy), std::move(cluster_name),
         std::move(eds_service_name), std::move(lrs_load_reporting_server_name),
-        std::move(drop_config));
+        max_concurrent_requests, std::move(drop_config));
   }
 
  private:
@@ -562,10 +783,13 @@ class EdsDropLbFactory : public LoadBalancingPolicyFactory {
 // Plugin registration
 //
 
-void grpc_lb_policy_eds_drop_init() {
+void grpc_lb_policy_xds_cluster_impl_init() {
+  grpc_core::g_call_counter_map = new grpc_core::CircuitBreakerCallCounterMap();
   grpc_core::LoadBalancingPolicyRegistry::Builder::
       RegisterLoadBalancingPolicyFactory(
-          absl::make_unique<grpc_core::EdsDropLbFactory>());
+          absl::make_unique<grpc_core::XdsClusterImplLbFactory>());
 }
 
-void grpc_lb_policy_eds_drop_shutdown() {}
+void grpc_lb_policy_xds_cluster_impl_shutdown() {
+  delete grpc_core::g_call_counter_map;
+}