grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/load_balancing/rls/rls.cc

@@ -53,7 +53,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/hash/hash.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -90,6 +89,7 @@
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -797,7 +797,7 @@ void RlsLb::ChildPolicyWrapper::StartUpdate(
   auto child_policy_config = InsertOrUpdateChildPolicyField(
       lb_policy_->config_->child_policy_config_target_field_name(), target_,
       lb_policy_->config_->child_policy_config(), &errors);
-  CHECK(child_policy_config.has_value());
+  GRPC_CHECK(child_policy_config.has_value());
   GRPC_TRACE_LOG(rls_lb, INFO)
       << "[rlslb " << lb_policy_.get() << "] ChildPolicyWrapper=" << this
       << " [" << target_
@@ -874,7 +874,7 @@ void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
       return;
     }
     wrapper_->connectivity_state_ = state;
-    DCHECK(picker != nullptr);
+    GRPC_DCHECK(picker != nullptr);
     if (picker != nullptr) {
       // We want to unref the picker after we release the lock.
       wrapper_->picker_.swap(picker);
@@ -898,7 +898,7 @@ std::map<std::string, std::string> BuildKeyMap(
   if (it == key_builder_map.end()) {
     // Didn't find exact match, try method wildcard.
     last_slash_pos = path.rfind('/');
-    DCHECK(last_slash_pos != path.npos);
+    GRPC_DCHECK(last_slash_pos != path.npos);
     if (GPR_UNLIKELY(last_slash_pos == path.npos)) return {};
     std::string service(path.substr(0, last_slash_pos + 1));
     it = key_builder_map.find(service);
@@ -930,7 +930,7 @@ std::map<std::string, std::string> BuildKeyMap(
   if (!key_builder->service_key.empty()) {
     if (last_slash_pos == path.npos) {
       last_slash_pos = path.rfind('/');
-      DCHECK(last_slash_pos != path.npos);
+      GRPC_DCHECK(last_slash_pos != path.npos);
       if (GPR_UNLIKELY(last_slash_pos == path.npos)) return {};
     }
     key_map[key_builder->service_key] =
@@ -940,7 +940,7 @@ std::map<std::string, std::string> BuildKeyMap(
   if (!key_builder->method_key.empty()) {
     if (last_slash_pos == path.npos) {
       last_slash_pos = path.rfind('/');
-      DCHECK(last_slash_pos != path.npos);
+      GRPC_DCHECK(last_slash_pos != path.npos);
       if (GPR_UNLIKELY(last_slash_pos == path.npos)) return {};
     }
     key_map[key_builder->method_key] =
@@ -1126,7 +1126,7 @@ void RlsLb::Cache::Entry::Orphan() {
   is_shutdown_ = true;
   lb_policy_->cache_.lru_list_.erase(lru_iterator_);
   lru_iterator_ = lb_policy_->cache_.lru_list_.end();  // Just in case.
-  CHECK(child_policy_wrappers_.empty());
+  GRPC_CHECK(child_policy_wrappers_.empty());
   backoff_state_.reset();
   if (backoff_timer_ != nullptr) {
     backoff_timer_.reset();
@@ -1137,7 +1137,7 @@ void RlsLb::Cache::Entry::Orphan() {
 
 size_t RlsLb::Cache::Entry::Size() const {
   // lru_iterator_ is not valid once we're shut down.
-  CHECK(!is_shutdown_);
+  GRPC_CHECK(!is_shutdown_);
   return lb_policy_->cache_.EntrySizeForKey(*lru_iterator_);
 }
 
@@ -1430,7 +1430,7 @@ void RlsLb::Cache::MaybeShrinkSize(
     auto lru_it = lru_list_.begin();
     if (GPR_UNLIKELY(lru_it == lru_list_.end())) break;
     auto map_it = map_.find(*lru_it);
-    CHECK(map_it != map_.end());
+    GRPC_CHECK(map_it != map_.end());
     auto& entry = map_it->second;
     if (!entry->CanEvict()) break;
     GRPC_TRACE_LOG(rls_lb, INFO)
@@ -1578,7 +1578,7 @@ void RlsLb::RlsChannel::Orphan() {
     // Remove channelz linkage.
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = channel_->channelz_node();
-      CHECK_NE(child_channelz_node, nullptr);
+      GRPC_CHECK_NE(child_channelz_node, nullptr);
       child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     // Stop connectivity watch.
@@ -1614,7 +1614,7 @@ void RlsLb::RlsChannel::ReportResponseLocked(bool response_succeeded) {
 }
 
 void RlsLb::RlsChannel::ResetBackoff() {
-  DCHECK(channel_ != nullptr);
+  GRPC_DCHECK(channel_ != nullptr);
   channel_->ResetConnectionBackoff();
 }
 
@@ -1647,7 +1647,7 @@ RlsLb::RlsRequest::RlsRequest(
       absl::OkStatus());
 }
 
-RlsLb::RlsRequest::~RlsRequest() { CHECK_EQ(call_, nullptr); }
+RlsLb::RlsRequest::~RlsRequest() { GRPC_CHECK_EQ(call_, nullptr); }
 
 void RlsLb::RlsRequest::Orphan() {
   if (call_ != nullptr) {
@@ -1707,7 +1707,7 @@ void RlsLb::RlsRequest::StartCallLocked() {
   Ref(DEBUG_LOCATION, "OnRlsCallComplete").release();
   auto call_error = grpc_call_start_batch_and_execute(
       call_, ops, static_cast<size_t>(op - ops), &call_complete_cb_);
-  CHECK_EQ(call_error, GRPC_CALL_OK);
+  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
 }
 
 void RlsLb::RlsRequest::OnRlsCallComplete(void* arg, grpc_error_handle error) {

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -27,7 +27,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
@@ -44,6 +43,7 @@
 #include "src/core/load_balancing/lb_policy_factory.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -208,8 +208,8 @@ RoundRobin::RoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
 RoundRobin::~RoundRobin() {
   GRPC_TRACE_LOG(round_robin, INFO)
       << "[RR " << this << "] Destroying Round Robin policy";
-  CHECK(endpoint_list_ == nullptr);
-  CHECK(latest_pending_endpoint_list_ == nullptr);
+  GRPC_CHECK(endpoint_list_ == nullptr);
+  GRPC_CHECK(latest_pending_endpoint_list_ == nullptr);
 }
 
 void RoundRobin::ShutdownLocked() {
@@ -315,20 +315,20 @@ void RoundRobin::RoundRobinEndpointList::UpdateStateCountersLocked(
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.
   if (old_state.has_value()) {
-    CHECK(*old_state != GRPC_CHANNEL_SHUTDOWN);
+    GRPC_CHECK(*old_state != GRPC_CHANNEL_SHUTDOWN);
     if (*old_state == GRPC_CHANNEL_READY) {
-      CHECK_GT(num_ready_, 0u);
+      GRPC_CHECK_GT(num_ready_, 0u);
       --num_ready_;
     } else if (*old_state == GRPC_CHANNEL_CONNECTING ||
                *old_state == GRPC_CHANNEL_IDLE) {
-      CHECK_GT(num_connecting_, 0u);
+      GRPC_CHECK_GT(num_connecting_, 0u);
       --num_connecting_;
     } else if (*old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      CHECK_GT(num_transient_failure_, 0u);
+      GRPC_CHECK_GT(num_transient_failure_, 0u);
       --num_transient_failure_;
     }
   }
-  CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
+  GRPC_CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
   if (new_state == GRPC_CHANNEL_READY) {
     ++num_ready_;
   } else if (new_state == GRPC_CHANNEL_CONNECTING ||
@@ -380,7 +380,7 @@ void RoundRobin::RoundRobinEndpointList::
         pickers.push_back(endpoint->picker());
       }
     }
-    CHECK(!pickers.empty());
+    GRPC_CHECK(!pickers.empty());
     round_robin->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_READY, absl::OkStatus(),
         MakeRefCounted<Picker>(round_robin, std::move(pickers)));

data/src/core/load_balancing/weighted_round_robin/static_stride_scheduler.cc

@@ -25,7 +25,7 @@
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -146,7 +146,7 @@ std::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
     }
   }
 
-  CHECK(weights.size() == float_weights.size());
+  GRPC_CHECK(weights.size() == float_weights.size());
   return StaticStrideScheduler{std::move(weights),
                                std::move(next_sequence_func)};
 }
@@ -156,7 +156,7 @@ StaticStrideScheduler::StaticStrideScheduler(
     absl::AnyInvocable<uint32_t()> next_sequence_func)
     : next_sequence_func_(std::move(next_sequence_func)),
       weights_(std::move(weights)) {
-  CHECK(next_sequence_func_ != nullptr);
+  GRPC_CHECK(next_sequence_func_ != nullptr);
 }
 
 size_t StaticStrideScheduler::Pick() const {

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -33,7 +33,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
@@ -62,6 +61,7 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -81,6 +81,8 @@ namespace {
 constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
 
 constexpr absl::string_view kMetricLabelLocality = "grpc.lb.locality";
+constexpr absl::string_view kMetricLabelBackendService =
+    "grpc.lb.backend_service";
 
 const auto kMetricRrFallback =
     GlobalInstrumentsRegistry::RegisterUInt64Counter(
@@ -90,7 +92,7 @@ const auto kMetricRrFallback =
         "fall back to RR behavior.",
         "{update}", false)
         .Labels(kMetricLabelTarget)
-        .OptionalLabels(kMetricLabelLocality)
+        .OptionalLabels(kMetricLabelLocality, kMetricLabelBackendService)
         .Build();
 
 const auto kMetricEndpointWeightNotYetUsable =
@@ -102,7 +104,7 @@ const auto kMetricEndpointWeightNotYetUsable =
         "period).",
         "{endpoint}", false)
         .Labels(kMetricLabelTarget)
-        .OptionalLabels(kMetricLabelLocality)
+        .OptionalLabels(kMetricLabelLocality, kMetricLabelBackendService)
         .Build();
 
 const auto kMetricEndpointWeightStale =
@@ -112,7 +114,7 @@ const auto kMetricEndpointWeightStale =
         "latest weight is older than the expiration period.",
         "{endpoint}", false)
         .Labels(kMetricLabelTarget)
-        .OptionalLabels(kMetricLabelLocality)
+        .OptionalLabels(kMetricLabelLocality, kMetricLabelBackendService)
         .Build();
 
 const auto kMetricEndpointWeights =
@@ -124,7 +126,7 @@ const auto kMetricEndpointWeights =
         "without usable weights will have weight 0.",
         "{weight}", false)
         .Labels(kMetricLabelTarget)
-        .OptionalLabels(kMetricLabelLocality)
+        .OptionalLabels(kMetricLabelLocality, kMetricLabelBackendService)
         .Build();
 
 // Config for WRR policy.
@@ -413,6 +415,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
       ABSL_GUARDED_BY(&endpoint_weight_map_mu_);
 
   const absl::string_view locality_name_;
+  const absl::string_view backend_service_name_;
 
   bool shutdown_ = false;
 
@@ -574,7 +577,7 @@ void WeightedRoundRobin::Picker::Orphaned() {
 
 WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
   size_t index = PickIndex();
-  CHECK(index < endpoints_.size());
+  GRPC_CHECK(index < endpoints_.size());
   auto& endpoint_info = endpoints_[index];
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << wrr_.get() << " picker " << this << "] returning index "
@@ -620,16 +623,18 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
         now, config_->weight_expiration_period(), config_->blackout_period(),
         &num_not_yet_usable, &num_stale);
     weights.push_back(weight);
-    stats_plugins.RecordHistogram(kMetricEndpointWeights, weight,
-                                  {wrr_->channel_control_helper()->GetTarget()},
-                                  {wrr_->locality_name_});
+    stats_plugins.RecordHistogram(
+        kMetricEndpointWeights, weight,
+        {wrr_->channel_control_helper()->GetTarget()},
+        {wrr_->locality_name_, wrr_->backend_service_name_});
   }
-  stats_plugins.AddCounter(
-      kMetricEndpointWeightNotYetUsable, num_not_yet_usable,
-      {wrr_->channel_control_helper()->GetTarget()}, {wrr_->locality_name_});
+  stats_plugins.AddCounter(kMetricEndpointWeightNotYetUsable,
+                           num_not_yet_usable,
+                           {wrr_->channel_control_helper()->GetTarget()},
+                           {wrr_->locality_name_, wrr_->backend_service_name_});
   stats_plugins.AddCounter(kMetricEndpointWeightStale, num_stale,
                            {wrr_->channel_control_helper()->GetTarget()},
-                           {wrr_->locality_name_});
+                           {wrr_->locality_name_, wrr_->backend_service_name_});
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << wrr_.get() << " picker " << this
       << "] new weights: " << absl::StrJoin(weights, " ");
@@ -646,9 +651,9 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
     GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
         << "[WRR " << wrr_.get() << " picker " << this
         << "] no scheduler, falling back to RR";
-    stats_plugins.AddCounter(kMetricRrFallback, 1,
-                             {wrr_->channel_control_helper()->GetTarget()},
-                             {wrr_->locality_name_});
+    stats_plugins.AddCounter(
+        kMetricRrFallback, 1, {wrr_->channel_control_helper()->GetTarget()},
+        {wrr_->locality_name_, wrr_->backend_service_name_});
   }
   {
     MutexLock lock(&scheduler_mu_);
@@ -689,17 +694,19 @@ WeightedRoundRobin::WeightedRoundRobin(Args args)
     : LoadBalancingPolicy(std::move(args)),
       locality_name_(channel_args()
                          .GetString(GRPC_ARG_LB_WEIGHTED_TARGET_CHILD)
-                         .value_or("")) {
+                         .value_or("")),
+      backend_service_name_(
+          channel_args().GetString(GRPC_ARG_BACKEND_SERVICE).value_or("")) {
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
-      << "[WRR " << this << "] Created -- locality_name=\""
-      << std::string(locality_name_) << "\"";
+      << "[WRR " << this << "] Created -- locality_name=\"" << locality_name_
+      << "\", backend_service_name=\"" << backend_service_name_ << "\"";
 }
 
 WeightedRoundRobin::~WeightedRoundRobin() {
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << this << "] Destroying Round Robin policy";
-  CHECK(endpoint_list_ == nullptr);
-  CHECK(latest_pending_endpoint_list_ == nullptr);
+  GRPC_CHECK(endpoint_list_ == nullptr);
+  GRPC_CHECK(latest_pending_endpoint_list_ == nullptr);
 }
 
 void WeightedRoundRobin::ShutdownLocked() {
@@ -898,20 +905,20 @@ void WeightedRoundRobin::WrrEndpointList::UpdateStateCountersLocked(
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.
   if (old_state.has_value()) {
-    CHECK(*old_state != GRPC_CHANNEL_SHUTDOWN);
+    GRPC_CHECK(*old_state != GRPC_CHANNEL_SHUTDOWN);
     if (*old_state == GRPC_CHANNEL_READY) {
-      CHECK_GT(num_ready_, 0u);
+      GRPC_CHECK_GT(num_ready_, 0u);
       --num_ready_;
     } else if (*old_state == GRPC_CHANNEL_CONNECTING ||
                *old_state == GRPC_CHANNEL_IDLE) {
-      CHECK_GT(num_connecting_, 0u);
+      GRPC_CHECK_GT(num_connecting_, 0u);
       --num_connecting_;
     } else if (*old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      CHECK_GT(num_transient_failure_, 0u);
+      GRPC_CHECK_GT(num_transient_failure_, 0u);
       --num_transient_failure_;
     }
   }
-  CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
+  GRPC_CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
   if (new_state == GRPC_CHANNEL_READY) {
     ++num_ready_;
   } else if (new_state == GRPC_CHANNEL_CONNECTING ||

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -31,7 +31,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
@@ -54,6 +53,7 @@
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -265,7 +265,7 @@ WeightedTargetLb::PickResult WeightedTargetLb::WeightedPicker::Pick(
     }
   }
   if (index == 0) index = start_index;
-  CHECK(pickers_[index].first > key);
+  GRPC_CHECK(pickers_[index].first > key);
   // Delegate to the child picker.
   return pickers_[index].second->Pick(args);
 }
@@ -394,7 +394,7 @@ void WeightedTargetLb::UpdateStateLocked() {
         << " weight=" << child->weight() << " picker=" << child_picker.get();
     switch (child->connectivity_state()) {
       case GRPC_CHANNEL_READY: {
-        CHECK_GT(child->weight(), 0u);
+        GRPC_CHECK_GT(child->weight(), 0u);
         ready_end += child->weight();
         ready_picker_list.emplace_back(ready_end, std::move(child_picker));
         break;
@@ -408,7 +408,7 @@ void WeightedTargetLb::UpdateStateLocked() {
         break;
       }
       case GRPC_CHANNEL_TRANSIENT_FAILURE: {
-        CHECK_GT(child->weight(), 0u);
+        GRPC_CHECK_GT(child->weight(), 0u);
         tf_end += child->weight();
         tf_picker_list.emplace_back(tf_end, std::move(child_picker));
         break;
@@ -482,7 +482,7 @@ void WeightedTargetLb::WeightedChild::DelayedRemovalTimer::Orphan() {
 }
 
 void WeightedTargetLb::WeightedChild::DelayedRemovalTimer::OnTimerLocked() {
-  CHECK(timer_handle_.has_value());
+  GRPC_CHECK(timer_handle_.has_value());
   timer_handle_.reset();
   weighted_child_->weighted_target_policy_->targets_.erase(
       weighted_child_->name_);