grpc 1.81.1 → 1.82.0.pre2

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "54.0.0"; }
+const char* grpc_version_string(void) { return "55.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "graphic"; }
+const char* grpc_g_stands_for(void) { return "glacier"; }

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

@@ -29,6 +29,7 @@
 #include <utility>
 
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
+#include "src/core/lib/event_engine/extensions/receive_coalescing_extension.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
@@ -224,11 +225,12 @@ class PromiseEndpoint {
   // Enables RPC receive coalescing and alignment of memory holding received
   // RPCs.
   void EnforceRxMemoryAlignmentAndCoalescing() {
-    auto* chaotic_good_ext = grpc_event_engine::experimental::QueryExtension<
-        grpc_event_engine::experimental::ChaoticGoodExtension>(endpoint_.get());
-    if (chaotic_good_ext != nullptr) {
-      chaotic_good_ext->EnforceRxMemoryAlignment();
-      chaotic_good_ext->EnableRpcReceiveCoalescing();
+    auto* ext = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::ReceiveCoalescingExtension>(
+        endpoint_.get());
+    if (ext != nullptr) {
+      ext->EnforceRxMemoryAlignment();
+      ext->EnableRpcReceiveCoalescing();
     }
   }
 

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/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,6 +34,7 @@
 #include <variant>
 #include <vector>
 
+#include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -52,6 +55,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/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
@@ -60,6 +64,7 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
+#include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -76,6 +81,14 @@
 
 namespace grpc_core {
 
+bool WrrCustomMetricsEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS");
+  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;
+}
+
 namespace {
 
 constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
@@ -129,66 +142,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 +328,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 +416,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 +596,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 +658,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 +892,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 +913,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

data/src/core/mitigation_engine/mitigation_engine.h

@@ -0,0 +1,81 @@
+//
+//
+// 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_MITIGATION_ENGINE_MITIGATION_ENGINE_H
+#define GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_ENGINE_H
+
+#include <optional>
+
+#include "src/core/call/metadata_batch.h"
+#include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/useful.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class MitigationEngine : public RefCounted<MitigationEngine> {
+ public:
+  enum class Action { kCloseConnection, kRejectRpc };
+  static absl::string_view ActionToString(Action action) {
+    switch (action) {
+      case Action::kCloseConnection:
+        return "Close Connection";
+      case Action::kRejectRpc:
+        return "Reject RPC";
+    }
+    return "Unknown Action";
+  }
+  ~MitigationEngine() override = default;
+  // Evaluates an incoming connection based on the peer address.
+  virtual std::optional<Action> EvaluateIncomingConnection(
+      absl::string_view peer_address) = 0;
+  // Evaluates an incoming metadata key/value pair. Please note that this
+  // function only evaluates *new* key/value pairs; if an incoming header has
+  // already been seen by the connection, it will not be evaluated again.
+  virtual std::optional<Action> EvaluateIncomingMetadata(
+      absl::string_view key, absl::string_view value) = 0;
+  // Evaluates all incoming metadata after they have been parsed.
+  virtual std::optional<Action> EvaluateAllIncomingMetadata(
+      const grpc_metadata_batch& metadata) = 0;
+};
+
+class MitigationEngineProvider
+    : public DualRefCounted<MitigationEngineProvider> {
+ public:
+  static absl::string_view ChannelArgName() {
+    return "grpc.internal.mitigation_engine_provider";
+  }
+
+  static int ChannelArgsCompare(const MitigationEngineProvider* a,
+                                const MitigationEngineProvider* b) {
+    return QsortCompare(a, b);
+  }
+
+  // Returns a reference to the current MitigationEngine, or nullptr if none
+  // is configured. An old engine will not be destroyed until all references
+  // to it are dropped.
+  virtual RefCountedPtr<MitigationEngine> GetEngine() = 0;
+
+  void Orphaned() override {}
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_MITIGATION_ENGINE_MITIGATION_ENGINE_H

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -53,7 +53,6 @@ extern void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder);
 extern void RegisterExtraFilters(CoreConfiguration::Builder* builder);
 extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
-extern void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder);
 extern void RegisterDnsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder);
 extern void RegisterSockaddrResolver(CoreConfiguration::Builder* builder);
@@ -127,7 +126,6 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterMessageSizeFilter(builder);
   RegisterServiceConfigChannelArgFilter(builder);
   RegisterResourceQuota(builder);
-  FaultInjectionFilterRegister(builder);
   RegisterDnsResolver(builder);
   RegisterSockaddrResolver(builder);
   RegisterFakeResolver(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -22,9 +22,6 @@
 namespace grpc_core {
 #ifndef GRPC_NO_XDS
 extern void RbacFilterRegister(CoreConfiguration::Builder* builder);
-extern void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder);
-extern void GcpAuthenticationFilterRegister(
-    CoreConfiguration::Builder* builder);
 extern void RegisterXdsChannelStackModifier(
     CoreConfiguration::Builder* builder);
 extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
@@ -49,8 +46,6 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the
   // re2 library by default
   RbacFilterRegister(builder);
-  StatefulSessionFilterRegister(builder);
-  GcpAuthenticationFilterRegister(builder);
   RegisterXdsChannelStackModifier(builder);
   RegisterChannelDefaultCreds(builder);
   RegisterDefaultCallCreds(builder);