grpc 1.53.0.pre2 → 1.54.0

data/src/core/ext/upbdefs-generated/envoy/service/status/v3/csds.upbdefs.c

@@ -19,7 +19,7 @@ extern _upb_DefPool_Init google_protobuf_timestamp_proto_upbdefinit;
 extern _upb_DefPool_Init envoy_annotations_deprecation_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_status_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_versioning_proto_upbdefinit;
-static const char descriptor[2758] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 'u', 's', '/', 'v', '3', 
+static const char descriptor[2755] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 'u', 's', '/', 'v', '3', 
 '/', 'c', 's', 'd', 's', '.', 'p', 'r', 'o', 't', 'o', '\022', '\027', 'e', 'n', 'v', 'o', 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 
 'e', '.', 's', 't', 'a', 't', 'u', 's', '.', 'v', '3', '\032', '\'', 'e', 'n', 'v', 'o', 'y', '/', 'a', 'd', 'm', 'i', 'n', '/', 
 'v', '3', '/', 'c', 'o', 'n', 'f', 'i', 'g', '_', 'd', 'u', 'm', 'p', '_', 's', 'h', 'a', 'r', 'e', 'd', '.', 'p', 'r', 'o', 
@@ -123,13 +123,13 @@ static const char descriptor[2758] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/',
 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 'e', '.', 's', 't', 'a', 't', 'u', 's', '.', 'v', '3', '.', 'C', 'l', 'i', 'e', 'n', 
 't', 'S', 't', 'a', 't', 'u', 's', 'R', 'e', 's', 'p', 'o', 'n', 's', 'e', '\"', ',', '\202', '\323', '\344', '\223', '\002', '\035', '\"', '\033', 
 '/', 'v', '3', '/', 'd', 'i', 's', 'c', 'o', 'v', 'e', 'r', 'y', ':', 'c', 'l', 'i', 'e', 'n', 't', '_', 's', 't', 'a', 't', 
-'u', 's', '\202', '\323', '\344', '\223', '\002', '\003', ':', '\001', '*', 'B', '\210', '\001', '\n', '%', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 
+'u', 's', '\202', '\323', '\344', '\223', '\002', '\003', ':', '\001', '*', 'B', '\205', '\001', '\n', '%', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 
 'r', 'o', 'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 'e', '.', 's', 't', 'a', 't', 'u', 's', 
 '.', 'v', '3', 'B', '\t', 'C', 's', 'd', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'G', 'g', 'i', 't', 'h', 'u', 'b', '.', 
 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 'o', 'l', 
 '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 
-'u', 's', '/', 'v', '3', ';', 's', 't', 'a', 't', 'u', 's', 'v', '3', '\210', '\001', '\001', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 
-'b', '\006', 'p', 'r', 'o', 't', 'o', '3', 
+'u', 's', '/', 'v', '3', ';', 's', 't', 'a', 't', 'u', 's', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 'p', 
+'r', 'o', 't', 'o', '3', 
 };
 
 static _upb_DefPool_Init *deps[10] = {
@@ -149,5 +149,5 @@ _upb_DefPool_Init envoy_service_status_v3_csds_proto_upbdefinit = {
   deps,
   &envoy_service_status_v3_csds_proto_upb_file_layout,
   "envoy/service/status/v3/csds.proto",
-  UPB_STRINGVIEW_INIT(descriptor, 2758)
+  UPB_STRINGVIEW_INIT(descriptor, 2755)
 };

data/src/core/ext/upbdefs-generated/envoy/type/matcher/v3/http_inputs.upbdefs.c

@@ -12,7 +12,7 @@
 
 extern _upb_DefPool_Init udpa_annotations_status_proto_upbdefinit;
 extern _upb_DefPool_Init validate_validate_proto_upbdefinit;
-static const char descriptor[579] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'h', 
+static const char descriptor[656] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'h', 
 't', 't', 'p', '_', 'i', 'n', 'p', 'u', 't', 's', '.', 'p', 'r', 'o', 't', 'o', '\022', '\025', 'e', 'n', 'v', 'o', 'y', '.', 't', 
 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', '\032', '\035', 'u', 'd', 'p', 'a', '/', 'a', 'n', 'n', 'o', 
 't', 'a', 't', 'i', 'o', 'n', 's', '/', 's', 't', 'a', 't', 'u', 's', '.', 'p', 'r', 'o', 't', 'o', '\032', '\027', 'v', 'a', 'l', 
@@ -29,13 +29,16 @@ static const char descriptor[579] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', '
 'a', 'm', 'e', '\"', 'M', '\n', '\035', 'H', 't', 't', 'p', 'R', 'e', 's', 'p', 'o', 'n', 's', 'e', 'T', 'r', 'a', 'i', 'l', 'e', 
 'r', 'M', 'a', 't', 'c', 'h', 'I', 'n', 'p', 'u', 't', '\022', ',', '\n', '\013', 'h', 'e', 'a', 'd', 'e', 'r', '_', 'n', 'a', 'm', 
 'e', '\030', '\001', ' ', '\001', '(', '\t', 'B', '\013', '\372', 'B', '\010', 'r', '\006', '\300', '\001', '\001', '\310', '\001', '\000', 'R', '\n', 'h', 'e', 'a', 
-'d', 'e', 'r', 'N', 'a', 'm', 'e', 'B', '\210', '\001', '\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', 
-'.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', 'B', '\017', 'H', 
-'t', 't', 'p', 'I', 'n', 'p', 'u', 't', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 'b', '.', 
-'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 'o', 'l', 
-'-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', 
-'/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 'p', 'r', 
-'o', 't', 'o', '3', 
+'d', 'e', 'r', 'N', 'a', 'm', 'e', '\"', 'K', '\n', '\037', 'H', 't', 't', 'p', 'R', 'e', 'q', 'u', 'e', 's', 't', 'Q', 'u', 'e', 
+'r', 'y', 'P', 'a', 'r', 'a', 'm', 'M', 'a', 't', 'c', 'h', 'I', 'n', 'p', 'u', 't', '\022', '(', '\n', '\013', 'q', 'u', 'e', 'r', 
+'y', '_', 'p', 'a', 'r', 'a', 'm', '\030', '\001', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', '\004', 'r', '\002', '\020', '\001', 'R', '\n', 'q', 
+'u', 'e', 'r', 'y', 'P', 'a', 'r', 'a', 'm', 'B', '\210', '\001', '\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 
+'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', 'B', 
+'\017', 'H', 't', 't', 'p', 'I', 'n', 'p', 'u', 't', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 
+'b', '.', 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 
+'o', 'l', '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 
+'e', 'r', '/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 
+'p', 'r', 'o', 't', 'o', '3', 
 };
 
 static _upb_DefPool_Init *deps[3] = {
@@ -48,5 +51,5 @@ _upb_DefPool_Init envoy_type_matcher_v3_http_inputs_proto_upbdefinit = {
   deps,
   &envoy_type_matcher_v3_http_inputs_proto_upb_file_layout,
   "envoy/type/matcher/v3/http_inputs.proto",
-  UPB_STRINGVIEW_INIT(descriptor, 579)
+  UPB_STRINGVIEW_INIT(descriptor, 656)
 };

data/src/core/ext/upbdefs-generated/envoy/type/matcher/v3/http_inputs.upbdefs.h

@@ -41,6 +41,11 @@ UPB_INLINE const upb_MessageDef *envoy_type_matcher_v3_HttpResponseTrailerMatchI
   return upb_DefPool_FindMessageByName(s, "envoy.type.matcher.v3.HttpResponseTrailerMatchInput");
 }
 
+UPB_INLINE const upb_MessageDef *envoy_type_matcher_v3_HttpRequestQueryParamMatchInput_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &envoy_type_matcher_v3_http_inputs_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "envoy.type.matcher.v3.HttpRequestQueryParamMatchInput");
+}
+
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif

data/src/core/ext/xds/xds_channel_stack_modifier.cc

@@ -62,8 +62,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
   auto it = builder->mutable_stack()->begin();
   while (it != builder->mutable_stack()->end()) {
     const char* filter_name_at_it = (*it)->name;
-    if (strcmp("census_server", filter_name_at_it) == 0 ||
-        strcmp("opencensus_server", filter_name_at_it) == 0) {
+    if (strcmp("census_server", filter_name_at_it) == 0) {
       break;
     }
     ++it;

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

@@ -131,29 +131,43 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
 
 XdsClusterLocalityStats::Snapshot
 XdsClusterLocalityStats::GetSnapshotAndReset() {
-  Snapshot snapshot = {
-      GetAndResetCounter(&total_successful_requests_),
-      // Don't reset total_requests_in_progress because it's
-      // not related to a single reporting interval.
-      total_requests_in_progress_.load(std::memory_order_relaxed),
-      GetAndResetCounter(&total_error_requests_),
-      GetAndResetCounter(&total_issued_requests_),
-      {}};
-  MutexLock lock(&backend_metrics_mu_);
-  snapshot.backend_metrics = std::move(backend_metrics_);
+  Snapshot snapshot;
+  for (auto& percpu_stats : stats_) {
+    Snapshot percpu_snapshot = {
+        GetAndResetCounter(&percpu_stats.total_successful_requests),
+        // Don't reset total_requests_in_progress because it's
+        // not related to a single reporting interval.
+        percpu_stats.total_requests_in_progress.load(std::memory_order_relaxed),
+        GetAndResetCounter(&percpu_stats.total_error_requests),
+        GetAndResetCounter(&percpu_stats.total_issued_requests),
+        {}};
+    {
+      MutexLock lock(&percpu_stats.backend_metrics_mu);
+      percpu_snapshot.backend_metrics = std::move(percpu_stats.backend_metrics);
+    }
+    snapshot += percpu_snapshot;
+  }
   return snapshot;
 }
 
 void XdsClusterLocalityStats::AddCallStarted() {
-  total_issued_requests_.fetch_add(1, std::memory_order_relaxed);
-  total_requests_in_progress_.fetch_add(1, std::memory_order_relaxed);
+  Stats& stats = stats_.this_cpu();
+  stats.total_issued_requests.fetch_add(1, std::memory_order_relaxed);
+  stats.total_requests_in_progress.fetch_add(1, std::memory_order_relaxed);
 }
 
-void XdsClusterLocalityStats::AddCallFinished(bool fail) {
+void XdsClusterLocalityStats::AddCallFinished(
+    const std::map<absl::string_view, double>* named_metrics, bool fail) {
+  Stats& stats = stats_.this_cpu();
   std::atomic<uint64_t>& to_increment =
-      fail ? total_error_requests_ : total_successful_requests_;
+      fail ? stats.total_error_requests : stats.total_successful_requests;
   to_increment.fetch_add(1, std::memory_order_relaxed);
-  total_requests_in_progress_.fetch_add(-1, std::memory_order_acq_rel);
+  stats.total_requests_in_progress.fetch_add(-1, std::memory_order_acq_rel);
+  if (named_metrics == nullptr) return;
+  MutexLock lock(&stats.backend_metrics_mu);
+  for (const auto& m : *named_metrics) {
+    stats.backend_metrics[std::string(m.first)] += BackendMetric{1, m.second};
+  }
 }
 
 }  // namespace grpc_core

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

@@ -34,6 +34,7 @@
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -159,8 +160,8 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
 class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
  public:
   struct BackendMetric {
-    uint64_t num_requests_finished_with_metric;
-    double total_metric_value;
+    uint64_t num_requests_finished_with_metric = 0;
+    double total_metric_value = 0;
 
     BackendMetric& operator+=(const BackendMetric& other) {
       num_requests_finished_with_metric +=
@@ -175,10 +176,10 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   };
 
   struct Snapshot {
-    uint64_t total_successful_requests;
-    uint64_t total_requests_in_progress;
-    uint64_t total_error_requests;
-    uint64_t total_issued_requests;
+    uint64_t total_successful_requests = 0;
+    uint64_t total_requests_in_progress = 0;
+    uint64_t total_error_requests = 0;
+    uint64_t total_issued_requests = 0;
     std::map<std::string, BackendMetric> backend_metrics;
 
     Snapshot& operator+=(const Snapshot& other) {
@@ -215,27 +216,30 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   Snapshot GetSnapshotAndReset();
 
   void AddCallStarted();
-  void AddCallFinished(bool fail = false);
+  void AddCallFinished(const std::map<absl::string_view, double>* named_metrics,
+                       bool fail = false);
 
  private:
+  struct Stats {
+    std::atomic<uint64_t> total_successful_requests{0};
+    std::atomic<uint64_t> total_requests_in_progress{0};
+    std::atomic<uint64_t> total_error_requests{0};
+    std::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 and the load reporting thread.
+    Mutex backend_metrics_mu;
+    std::map<std::string, BackendMetric> backend_metrics
+        ABSL_GUARDED_BY(backend_metrics_mu);
+  };
+
   RefCountedPtr<XdsClient> xds_client_;
   const XdsBootstrap::XdsServer& lrs_server_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
-
-  std::atomic<uint64_t> total_successful_requests_{0};
-  std::atomic<uint64_t> total_requests_in_progress_{0};
-  std::atomic<uint64_t> total_error_requests_{0};
-  std::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 work serializer)
-  // and the load reporting thread (from the control plane work serializer).
-  Mutex backend_metrics_mu_;
-  std::map<std::string, BackendMetric> backend_metrics_
-      ABSL_GUARDED_BY(backend_metrics_mu_);
+  PerCpu<Stats> stats_{32};
 };
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_endpoint.cc

@@ -93,11 +93,14 @@ std::string XdsEndpointResource::Priority::ToString() const {
 }
 
 bool XdsEndpointResource::DropConfig::ShouldDrop(
-    const std::string** category_name) const {
+    const std::string** category_name) {
   for (size_t i = 0; i < drop_category_list_.size(); ++i) {
     const auto& drop_category = drop_category_list_[i];
     // Generate a random number in [0, 1000000).
-    const uint32_t random = static_cast<uint32_t>(rand()) % 1000000;
+    const uint32_t random = [&]() {
+      MutexLock lock(&mu_);
+      return absl::Uniform<uint32_t>(bit_gen_, 0, 1000000);
+    }();
     if (random < drop_category.parts_per_million) {
       *category_name = &drop_category.name;
       return true;

data/src/core/ext/xds/xds_endpoint.h

@@ -28,6 +28,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/random/random.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "upb/def.h"
@@ -38,6 +40,7 @@
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
@@ -90,7 +93,7 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
 
     // The only method invoked from outside the WorkSerializer (used in
     // the data plane).
-    bool ShouldDrop(const std::string** category_name) const;
+    bool ShouldDrop(const std::string** category_name);
 
     const DropCategoryList& drop_category_list() const {
       return drop_category_list_;
@@ -108,6 +111,11 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
    private:
     DropCategoryList drop_category_list_;
     bool drop_all_ = false;
+
+    // TODO(roth): Consider using a separate thread-local BitGen for each CPU
+    // to avoid the need for this mutex.
+    Mutex mu_;
+    absl::BitGen bit_gen_ ABSL_GUARDED_BY(&mu_);
   };
 
   PriorityList priorities;

data/src/core/ext/xds/xds_http_rbac_filter.cc

@@ -396,7 +396,7 @@ Json ParseHttpRbacToJson(const envoy_extensions_filters_http_rbac_v3_RBAC* rbac,
     }
     Json::Object inner_rbac_json;
     inner_rbac_json.emplace("action", envoy_config_rbac_v3_RBAC_action(rules));
-    if (envoy_config_rbac_v3_RBAC_has_policies(rules)) {
+    if (envoy_config_rbac_v3_RBAC_policies_size(rules) != 0) {
       Json::Object policies_object;
       size_t iter = kUpb_Map_Begin;
       while (true) {

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -124,6 +124,19 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
       Duration duration = ParseDuration(duration_proto, errors);
       config["weightExpirationPeriod"] = duration.ToJsonString();
     }
+    // error_utilization_penalty
+    auto* error_utilization_penalty =
+        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_error_utilization_penalty(
+            resource);
+    if (error_utilization_penalty != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".error_utilization_penalty");
+      const float value =
+          google_protobuf_FloatValue_value(error_utilization_penalty);
+      if (value < 0.0) {
+        errors->AddError("value must be non-negative");
+      }
+      config["errorUtilizationPenalty"] = value;
+    }
     return Json::Object{
         {"weighted_round_robin_experimental", std::move(config)}};
   }

data/src/core/ext/xds/xds_transport_grpc.cc

@@ -291,7 +291,7 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcXdsTransport(
 }
 
 GrpcXdsTransportFactory::GrpcXdsTransport::~GrpcXdsTransport() {
-  grpc_channel_destroy(channel_);
+  grpc_channel_destroy_internal(channel_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::Orphan() {

data/src/core/{ext/filters/client_channel/resolver/dns/dns_resolver_selection.h → lib/backoff/random_early_detection.cc}

@@ -1,6 +1,4 @@
-//
-//
-// Copyright 2019 gRPC authors.
+// Copyright 2023 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,17 +11,21 @@
 // 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_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/global_config_generic.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/backoff/random_early_detection.h"
+
+namespace grpc_core {
 
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_dns_resolver);
+bool RandomEarlyDetection::Reject(uint64_t size) {
+  if (size <= soft_limit_) return false;
+  if (size < hard_limit_) {
+    return absl::Bernoulli(bitgen_,
+                           static_cast<double>(size - soft_limit_) /
+                               static_cast<double>(hard_limit_ - soft_limit_));
+  }
+  return true;
+}
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_DNS_RESOLVER_SELECTION_H
+}  // namespace grpc_core

data/src/core/lib/backoff/random_early_detection.h

@@ -0,0 +1,59 @@
+// Copyright 2023 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_LIB_BACKOFF_RANDOM_EARLY_DETECTION_H
+#define GRPC_SRC_CORE_LIB_BACKOFF_RANDOM_EARLY_DETECTION_H
+
+#include <grpc/support/port_platform.h>
+
+#include <limits.h>
+
+#include <cstdint>
+
+#include "absl/random/random.h"
+
+namespace grpc_core {
+
+// Implements the random early detection algorithm - allows items to be rejected
+// or accepted based upon their size.
+class RandomEarlyDetection {
+ public:
+  RandomEarlyDetection() : soft_limit_(INT_MAX), hard_limit_(INT_MAX) {}
+  RandomEarlyDetection(uint64_t soft_limit, uint64_t hard_limit)
+      : soft_limit_(soft_limit), hard_limit_(hard_limit) {}
+
+  // Returns true if the size is greater than or equal to the hard limit - ie if
+  // this item must be rejected.
+  bool MustReject(uint64_t size) { return size >= hard_limit_; }
+
+  // Returns true if the item should be rejected.
+  bool Reject(uint64_t size);
+
+  uint64_t soft_limit() const { return soft_limit_; }
+  uint64_t hard_limit() const { return hard_limit_; }
+
+ private:
+  // The soft limit is the size at which we start rejecting items with a
+  // probability that increases linearly to 1 as the size approaches the hard
+  // limit.
+  uint64_t soft_limit_;
+  // The hard limit is the size at which we reject all items.
+  uint64_t hard_limit_;
+  // The bit generator used to generate random numbers.
+  absl::InsecureBitGen bitgen_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_BACKOFF_RANDOM_EARLY_DETECTION_H

data/src/core/lib/channel/call_finalization.h

@@ -36,7 +36,7 @@ class CallFinalization {
  public:
   // Add a step to the finalization context.
   // Takes a callable with a signature compatible with:
-  // (const grpc_call_final_info&) -> void.
+  // (const grpc_call_final_info*) -> void.
   // Finalizers are run in the reverse order they are added.
   template <typename F>
   void Add(F&& t) {

data/src/core/lib/channel/call_tracer.cc

@@ -0,0 +1,51 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/call_tracer.h"
+
+namespace grpc_core {
+
+//
+// ServerCallTracerFactory
+//
+
+namespace {
+ServerCallTracerFactory* g_server_call_tracer_factory_ = nullptr;
+
+const char* kServerCallTracerFactoryChannelArgName =
+    "grpc.experimental.server_call_tracer_factory";
+}  // namespace
+
+ServerCallTracerFactory* ServerCallTracerFactory::Get(
+    const ChannelArgs& channel_args) {
+  ServerCallTracerFactory* factory =
+      channel_args.GetObject<ServerCallTracerFactory>();
+  return factory != nullptr ? factory : g_server_call_tracer_factory_;
+}
+
+void ServerCallTracerFactory::RegisterGlobal(ServerCallTracerFactory* factory) {
+  g_server_call_tracer_factory_ = factory;
+}
+
+absl::string_view ServerCallTracerFactory::ChannelArgName() {
+  return kServerCallTracerFactoryChannelArgName;
+}
+
+}  // namespace grpc_core