grpc 1.81.1 → 1.83.0

data/src/core/lib/transport/transport.h

@@ -41,6 +41,7 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -49,8 +50,10 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/call_final_info.h"
@@ -114,21 +117,45 @@ class ClientInitialMetadataOutstandingToken {
       : latch_(std::exchange(other.latch_, nullptr)) {}
   ClientInitialMetadataOutstandingToken& operator=(
       ClientInitialMetadataOutstandingToken&& other) noexcept {
+    if (IsMetadataOutstandingTokenRefactorEnabled()) {
+      MaybeSet(false);
+    }
     latch_ = std::exchange(other.latch_, nullptr);
     return *this;
   }
   ~ClientInitialMetadataOutstandingToken() {
-    if (latch_ != nullptr) latch_->Set(false);
+    if (IsMetadataOutstandingTokenRefactorEnabled()) {
+      MaybeSet(false);
+    } else {
+      if (latch_ != nullptr) latch_->Set(false);
+    }
+  }
+  void Complete(bool success) {
+    if (IsMetadataOutstandingTokenRefactorEnabled()) {
+      MaybeSet(success);
+    } else {
+      if (latch_ != nullptr) std::exchange(latch_, nullptr)->Set(success);
+    }
   }
-  void Complete(bool success) { std::exchange(latch_, nullptr)->Set(success); }
 
   // Returns a promise that will resolve when this object (or its moved-from
-  // ancestor) is dropped.
-  auto Wait() { return latch_->Wait(); }
+  // ancestor) is dropped. If the token is Empty(), the promise resolves to
+  // false immediately (when the refactor experiment is enabled).
+  auto Wait() {
+    return If(
+        latch_ != nullptr, [latch = latch_]() { return latch->Wait(); },
+        []() { return Immediate(false); });
+  }
 
  private:
   ClientInitialMetadataOutstandingToken() = default;
 
+  void MaybeSet(bool status) {
+    if (latch_ != nullptr && !latch_->is_set()) {
+      latch_->Set(status);
+    }
+  }
+
   Latch<bool>* latch_ = nullptr;
 };
 

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -880,7 +880,8 @@ GrpcLb::BalancerCallState::BalancerCallState(
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
       /*cq=*/nullptr, grpclb_policy_->interested_parties(),
       Slice::FromStaticString("/grpc.lb.v1.LoadBalancer/BalanceLoad"),
-      /*authority=*/std::nullopt, deadline, /*registered_method=*/true);
+      /*authority=*/std::nullopt, deadline, /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
   // Init the LB call request payload.
   upb::Arena arena;
   grpc_slice request_payload_slice = GrpcLbRequestCreate(

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <cmath>
 #include <memory>
 #include <optional>
 #include <set>
@@ -32,6 +33,7 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -538,8 +540,33 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
       // Shuffle the list if needed.
       auto config = static_cast<PickFirstConfig*>(args.config.get());
       if (config->shuffle_addresses()) {
-        SharedBitGen g;
-        absl::c_shuffle(endpoints, g);
+        if (PfWeightedShufflingEnabled()) {
+          struct WeightedEndpoint {
+            EndpointAddresses endpoint;
+            double key;
+          };
+          std::vector<WeightedEndpoint> weighted_endpoints;
+          weighted_endpoints.reserve(endpoints.size());
+          SharedBitGen g;
+          for (auto& endpoint : endpoints) {
+            double e = absl::Exponential<double>(g);
+            int weight_arg =
+                endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+            double weight = weight_arg <= 0 ? 1.0 : weight_arg;
+            double key = (weight == 1.0) ? e : (e / weight);
+            weighted_endpoints.push_back({std::move(endpoint), key});
+          }
+          std::sort(weighted_endpoints.begin(), weighted_endpoints.end(),
+                    [](const WeightedEndpoint& a, const WeightedEndpoint& b) {
+                      return a.key < b.key;
+                    });
+          for (size_t i = 0; i < weighted_endpoints.size(); ++i) {
+            endpoints[i] = std::move(weighted_endpoints[i].endpoint);
+          }
+        } else {
+          SharedBitGen g;
+          absl::c_shuffle(endpoints, g);
+        }
       }
       // Flatten the list so that we have one address per endpoint.
       // While we're iterating, also determine the desired address family
@@ -1159,6 +1186,10 @@ class PickFirstFactory final : public LoadBalancingPolicyFactory {
 
 }  // namespace
 
+bool PfWeightedShufflingEnabled() {
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_PF_WEIGHTED_SHUFFLING");
+}
+
 void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
       std::make_unique<PickFirstFactory>());

data/src/core/load_balancing/pick_first/pick_first.h

@@ -33,4 +33,10 @@
 #define GRPC_ARG_INTERNAL_PICK_FIRST_OMIT_STATUS_MESSAGE_PREFIX \
   GRPC_ARG_NO_SUBCHANNEL_PREFIX "pick_first_omit_status_message_prefix"
 
+namespace grpc_core {
+
+bool PfWeightedShufflingEnabled();
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_PICK_FIRST_PICK_FIRST_H

data/src/core/load_balancing/ring_hash/ring_hash.cc

@@ -34,6 +34,7 @@
 
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -51,7 +52,6 @@
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
-#include "src/core/util/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
@@ -81,19 +81,12 @@ namespace {
 
 constexpr absl::string_view kRingHash = "ring_hash_experimental";
 
-bool XdsRingHashSetRequestHashKeyEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 class RingHashJsonArgs final : public JsonArgs {
  public:
   bool IsEnabled(absl::string_view key) const override {
     if (key == "request_hash_header") {
-      return XdsRingHashSetRequestHashKeyEnabled();
+      return IsExperimentEnvVarEnabled(
+          "GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY");
     }
     return true;
   }

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

@@ -1680,7 +1680,8 @@ void RlsLb::RlsRequest::StartCallLocked() {
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS, /*cq=*/nullptr,
       lb_policy_->interested_parties(),
       Slice::FromStaticString(kRlsRequestPath), /*authority=*/std::nullopt,
-      deadline_, /*registered_method=*/true);
+      deadline_, /*registered_method=*/true,
+      /*arena_init_function=*/std::nullopt);
   grpc_op ops[6];
   memset(ops, 0, sizeof(ops));
   grpc_op* op = ops;

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

@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#include "src/core/load_balancing/weighted_round_robin/weighted_round_robin.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/port_platform.h>
@@ -32,7 +34,9 @@
 #include <variant>
 #include <vector>
 
+#include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -76,6 +80,10 @@
 
 namespace grpc_core {
 
+bool WrrCustomMetricsEnabled() {
+  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS");
+}
+
 namespace {
 
 constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
@@ -129,66 +137,129 @@ const auto kMetricEndpointWeights =
         .OptionalLabels(kMetricLabelLocality, kMetricLabelBackendService)
         .Build();
 
-// Config for WRR policy.
-class WeightedRoundRobinConfig final : public LoadBalancingPolicy::Config {
- public:
-  WeightedRoundRobinConfig() = default;
-
-  WeightedRoundRobinConfig(const WeightedRoundRobinConfig&) = delete;
-  WeightedRoundRobinConfig& operator=(const WeightedRoundRobinConfig&) = delete;
+double GetUtilization(const BackendMetricData& backend_metric_data,
+                      const std::vector<WeightedRoundRobinConfig::ParsedMetric>&
+                          parsed_custom_metrics) {
+  double utilization = 0;
+  bool custom_metric_found = false;
+  if (!parsed_custom_metrics.empty()) {
+    for (const auto& metric : parsed_custom_metrics) {
+      double value = 0;
+      switch (metric.type) {
+        case WeightedRoundRobinConfig::ParsedMetric::Type::kCpu:
+          value = backend_metric_data.cpu_utilization;
+          break;
+        case WeightedRoundRobinConfig::ParsedMetric::Type::kMem:
+          value = backend_metric_data.mem_utilization;
+          break;
+        case WeightedRoundRobinConfig::ParsedMetric::Type::kApplication:
+          value = backend_metric_data.application_utilization;
+          break;
+        case WeightedRoundRobinConfig::ParsedMetric::Type::kNamedMetric: {
+          auto it = backend_metric_data.named_metrics.find(metric.name);
+          if (it != backend_metric_data.named_metrics.end()) {
+            value = it->second;
+          }
+          break;
+        }
+        case WeightedRoundRobinConfig::ParsedMetric::Type::kUtilization: {
+          auto it = backend_metric_data.utilization.find(metric.name);
+          if (it != backend_metric_data.utilization.end()) {
+            value = it->second;
+          }
+          break;
+        }
+      }
+      if (value > 0) {
+        utilization = std::max(utilization, value);
+        custom_metric_found = true;
+      }
+    }
+  }
+  if (!custom_metric_found) {
+    utilization = backend_metric_data.application_utilization;
+  }
+  if (utilization <= 0) {
+    utilization = backend_metric_data.cpu_utilization;
+  }
+  return utilization;
+}
+}  // namespace
 
-  WeightedRoundRobinConfig(WeightedRoundRobinConfig&&) = delete;
-  WeightedRoundRobinConfig& operator=(WeightedRoundRobinConfig&&) = delete;
+absl::string_view WeightedRoundRobinConfig::name() const {
+  return kWeightedRoundRobin;
+}
 
-  absl::string_view name() const override { return kWeightedRoundRobin; }
+const JsonLoaderInterface* WeightedRoundRobinConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<WeightedRoundRobinConfig>()
+          .OptionalField("enableOobLoadReport",
+                         &WeightedRoundRobinConfig::enable_oob_load_report_)
+          .OptionalField("oobReportingPeriod",
+                         &WeightedRoundRobinConfig::oob_reporting_period_)
+          .OptionalField("blackoutPeriod",
+                         &WeightedRoundRobinConfig::blackout_period_)
+          .OptionalField("weightUpdatePeriod",
+                         &WeightedRoundRobinConfig::weight_update_period_)
+          .OptionalField("weightExpirationPeriod",
+                         &WeightedRoundRobinConfig::weight_expiration_period_)
+          .OptionalField("errorUtilizationPenalty",
+                         &WeightedRoundRobinConfig::error_utilization_penalty_)
+          .Finish();
+  return loader;
+}
 
-  bool enable_oob_load_report() const { return enable_oob_load_report_; }
-  Duration oob_reporting_period() const { return oob_reporting_period_; }
-  Duration blackout_period() const { return blackout_period_; }
-  Duration weight_update_period() const { return weight_update_period_; }
-  Duration weight_expiration_period() const {
-    return weight_expiration_period_;
-  }
-  float error_utilization_penalty() const { return error_utilization_penalty_; }
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
-    static const auto* loader =
-        JsonObjectLoader<WeightedRoundRobinConfig>()
-            .OptionalField("enableOobLoadReport",
-                           &WeightedRoundRobinConfig::enable_oob_load_report_)
-            .OptionalField("oobReportingPeriod",
-                           &WeightedRoundRobinConfig::oob_reporting_period_)
-            .OptionalField("blackoutPeriod",
-                           &WeightedRoundRobinConfig::blackout_period_)
-            .OptionalField("weightUpdatePeriod",
-                           &WeightedRoundRobinConfig::weight_update_period_)
-            .OptionalField("weightExpirationPeriod",
-                           &WeightedRoundRobinConfig::weight_expiration_period_)
-            .OptionalField(
-                "errorUtilizationPenalty",
-                &WeightedRoundRobinConfig::error_utilization_penalty_)
-            .Finish();
-    return loader;
-  }
-
-  void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
-    // Impose lower bound of 100ms on weightUpdatePeriod.
-    weight_update_period_ =
-        std::max(weight_update_period_, Duration::Milliseconds(100));
-    if (error_utilization_penalty_ < 0) {
-      ValidationErrors::ScopedField field(errors, ".errorUtilizationPenalty");
-      errors->AddError("must be non-negative");
+void WeightedRoundRobinConfig::JsonPostLoad(const Json& json,
+                                            const JsonArgs& args,
+                                            ValidationErrors* errors) {
+  // Impose lower bound of 100ms on weightUpdatePeriod.
+  weight_update_period_ =
+      std::max(weight_update_period_, Duration::Milliseconds(100));
+  if (error_utilization_penalty_ < 0) {
+    ValidationErrors::ScopedField field(errors, ".errorUtilizationPenalty");
+    errors->AddError("must be non-negative");
+  }
+  if (WrrCustomMetricsEnabled()) {
+    std::optional<std::vector<std::string>>
+        metric_names_for_computing_utilization =
+            LoadJsonObjectField<std::vector<std::string>>(
+                json.object(), args, "metricNamesForComputingUtilization",
+                errors, /*required=*/false);
+    if (metric_names_for_computing_utilization.has_value()) {
+      size_t i = 0;
+      for (const auto& metric_name : *metric_names_for_computing_utilization) {
+        if (metric_name == "cpu_utilization") {
+          parsed_custom_metrics_.push_back(
+              {WeightedRoundRobinConfig::ParsedMetric::Type::kCpu, ""});
+        } else if (metric_name == "mem_utilization") {
+          parsed_custom_metrics_.push_back(
+              {WeightedRoundRobinConfig::ParsedMetric::Type::kMem, ""});
+        } else if (metric_name == "application_utilization") {
+          parsed_custom_metrics_.push_back(
+              {WeightedRoundRobinConfig::ParsedMetric::Type::kApplication, ""});
+        } else if (absl::StartsWith(metric_name, "named_metrics.")) {
+          parsed_custom_metrics_.push_back(
+              {WeightedRoundRobinConfig::ParsedMetric::Type::kNamedMetric,
+               std::string(absl::StripPrefix(metric_name, "named_metrics."))});
+        } else if (absl::StartsWith(metric_name, "utilization.")) {
+          parsed_custom_metrics_.push_back(
+              {WeightedRoundRobinConfig::ParsedMetric::Type::kUtilization,
+               std::string(absl::StripPrefix(metric_name, "utilization."))});
+        } else {
+          ValidationErrors::ScopedField field(
+              errors,
+              absl::StrCat(".metricNamesForComputingUtilization[", i, "]"));
+          errors->AddError(
+              absl::StrCat("unsupported metric name \"", metric_name, "\""));
+        }
+        ++i;
+      }
     }
   }
+}
 
- private:
-  bool enable_oob_load_report_ = false;
-  Duration oob_reporting_period_ = Duration::Seconds(10);
-  Duration blackout_period_ = Duration::Seconds(10);
-  Duration weight_update_period_ = Duration::Seconds(1);
-  Duration weight_expiration_period_ = Duration::Minutes(3);
-  float error_utilization_penalty_ = 1.0;
-};
+namespace {
 
 // WRR LB policy
 class WeightedRoundRobin final : public LoadBalancingPolicy {
@@ -252,16 +323,15 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
       class OobWatcher final : public OobBackendMetricWatcher {
        public:
         OobWatcher(RefCountedPtr<EndpointWeight> weight,
-                   float error_utilization_penalty)
-            : weight_(std::move(weight)),
-              error_utilization_penalty_(error_utilization_penalty) {}
+                   RefCountedPtr<WeightedRoundRobinConfig> config)
+            : weight_(std::move(weight)), config_(std::move(config)) {}
 
         void OnBackendMetricReport(
             const BackendMetricData& backend_metric_data) override;
 
        private:
         RefCountedPtr<EndpointWeight> weight_;
-        const float error_utilization_penalty_;
+        RefCountedPtr<WeightedRoundRobinConfig> config_;
       };
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
@@ -341,17 +411,18 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
     class SubchannelCallTracker final : public SubchannelCallTrackerInterface {
      public:
       SubchannelCallTracker(
-          RefCountedPtr<EndpointWeight> weight, float error_utilization_penalty,
+          RefCountedPtr<EndpointWeight> weight,
+          RefCountedPtr<WeightedRoundRobinConfig> config,
           std::unique_ptr<SubchannelCallTrackerInterface> child_tracker)
           : weight_(std::move(weight)),
-            error_utilization_penalty_(error_utilization_penalty),
+            config_(std::move(config)),
             child_tracker_(std::move(child_tracker)) {}
 
       void Finish(FinishArgs args) override;
 
      private:
       RefCountedPtr<EndpointWeight> weight_;
-      const float error_utilization_penalty_;
+      RefCountedPtr<WeightedRoundRobinConfig> config_;
       std::unique_ptr<SubchannelCallTrackerInterface> child_tracker_;
     };
 
@@ -520,12 +591,11 @@ void WeightedRoundRobin::Picker::SubchannelCallTracker::Finish(
   if (backend_metric_data != nullptr) {
     qps = backend_metric_data->qps;
     eps = backend_metric_data->eps;
-    utilization = backend_metric_data->application_utilization;
-    if (utilization <= 0) {
-      utilization = backend_metric_data->cpu_utilization;
-    }
+    utilization =
+        GetUtilization(*backend_metric_data, config_->parsed_custom_metrics());
   }
-  weight_->MaybeUpdateWeight(qps, eps, utilization, error_utilization_penalty_);
+  weight_->MaybeUpdateWeight(qps, eps, utilization,
+                             config_->error_utilization_penalty());
 }
 
 //
@@ -583,7 +653,7 @@ WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
     if (complete != nullptr) {
       complete->subchannel_call_tracker =
           std::make_unique<SubchannelCallTracker>(
-              endpoint_info.weight, config_->error_utilization_penalty(),
+              endpoint_info.weight, config_,
               std::move(complete->subchannel_call_tracker));
     }
   }
@@ -817,12 +887,10 @@ WeightedRoundRobin::GetOrCreateWeight(
 
 void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OobWatcher::
     OnBackendMetricReport(const BackendMetricData& backend_metric_data) {
-  double utilization = backend_metric_data.application_utilization;
-  if (utilization <= 0) {
-    utilization = backend_metric_data.cpu_utilization;
-  }
+  double utilization =
+      GetUtilization(backend_metric_data, config_->parsed_custom_metrics());
   weight_->MaybeUpdateWeight(backend_metric_data.qps, backend_metric_data.eps,
-                             utilization, error_utilization_penalty_);
+                             utilization, config_->error_utilization_penalty());
 }
 
 //
@@ -840,8 +908,7 @@ WeightedRoundRobin::WrrEndpointList::WrrEndpoint::CreateSubchannel(
   if (wrr->config_->enable_oob_load_report()) {
     subchannel->AddDataWatcher(MakeOobBackendMetricWatcher(
         wrr->config_->oob_reporting_period(),
-        std::make_unique<OobWatcher>(
-            weight_, wrr->config_->error_utilization_penalty())));
+        std::make_unique<OobWatcher>(weight_, wrr->config_)));
   }
   return subchannel;
 }

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.h

@@ -0,0 +1,88 @@
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_ROUND_ROBIN_WEIGHTED_ROUND_ROBIN_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_ROUND_ROBIN_WEIGHTED_ROUND_ROBIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+#include <vector>
+
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+bool WrrCustomMetricsEnabled();
+
+class WeightedRoundRobinConfig final : public LoadBalancingPolicy::Config {
+ public:
+  struct ParsedMetric {
+    enum class Type {
+      kCpu,
+      kMem,
+      kApplication,
+      kNamedMetric,
+      kUtilization,
+    };
+    Type type;
+    std::string name;
+  };
+
+  WeightedRoundRobinConfig() = default;
+
+  WeightedRoundRobinConfig(const WeightedRoundRobinConfig&) = delete;
+  WeightedRoundRobinConfig& operator=(const WeightedRoundRobinConfig&) = delete;
+
+  WeightedRoundRobinConfig(WeightedRoundRobinConfig&&) = delete;
+  WeightedRoundRobinConfig& operator=(WeightedRoundRobinConfig&&) = delete;
+
+  absl::string_view name() const override;
+
+  bool enable_oob_load_report() const { return enable_oob_load_report_; }
+  Duration oob_reporting_period() const { return oob_reporting_period_; }
+  Duration blackout_period() const { return blackout_period_; }
+  Duration weight_update_period() const { return weight_update_period_; }
+  Duration weight_expiration_period() const {
+    return weight_expiration_period_;
+  }
+  float error_utilization_penalty() const { return error_utilization_penalty_; }
+  const std::vector<ParsedMetric>& parsed_custom_metrics() const {
+    return parsed_custom_metrics_;
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs& args);
+
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
+ private:
+  bool enable_oob_load_report_ = false;
+  Duration oob_reporting_period_ = Duration::Seconds(10);
+  Duration blackout_period_ = Duration::Seconds(10);
+  Duration weight_update_period_ = Duration::Seconds(1);
+  Duration weight_expiration_period_ = Duration::Minutes(3);
+  float error_utilization_penalty_ = 1.0;
+  std::vector<ParsedMetric> parsed_custom_metrics_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_ROUND_ROBIN_WEIGHTED_ROUND_ROBIN_H