grpc 1.83.1 → 1.84.0

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

@@ -42,20 +42,4 @@ void grpc_error_get_status(grpc_error_handle error,
                            grpc_core::http2::Http2ErrorCode* http_error,
                            const char** error_string);
 
-/// Utility Function to convert a grpc_error_handle  \a error to an
-/// absl::Status. Does NOT consume a ref to grpc_error.
-absl::Status grpc_error_to_absl_status(grpc_error_handle error);
-
-/// Utility function to convert an absl::Status \a status to grpc_error. Note
-/// that this method does not return "special case" errors such as
-/// absl::CancelledError(), with the exception of absl::OkStatus() returned for
-/// \a absl::OkStatus().
-grpc_error_handle absl_status_to_grpc_error(absl::Status status);
-
-/// A utility function to check whether there is a clear status code that
-/// doesn't need to be guessed in \a error. This means that \a error or some
-/// child has grpc_core::StatusIntProperty::kRpcStatus set, or that it is
-/// absl::OkStatus() or absl::CancelledError()
-bool grpc_error_has_clear_grpc_status(grpc_error_handle error);
-
 #endif  // GRPC_SRC_CORE_LIB_TRANSPORT_ERROR_UTILS_H

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

@@ -417,11 +417,10 @@ struct grpc_transport_stream_op_batch_payload {
 
   /// Forcefully close this stream.
   /// The HTTP2 semantics should be:
-  /// - server side: if cancel_error has
-  /// grpc_core::StatusIntProperty::kRpcStatus, and trailing metadata has not
-  /// been sent, send trailing metadata with status and message from
-  /// cancel_error (use grpc_error_get_status) followed by a RST_STREAM with
-  /// error=GRPC_CHTTP2_NO_ERROR to force a full close
+  /// - server side: if cancel_error is not UNKNOWN and trailing
+  ///   metadata has not been sent, send trailing metadata with status and
+  //    message from cancel_error (use grpc_error_get_status) followed by a
+  //    RST_STREAM with error=GRPC_CHTTP2_NO_ERROR to force a full close
   /// - at all other times: use grpc_error_get_status to get a status code, and
   ///   convert to a HTTP2 error code using
   ///   grpc_chttp2_grpc_status_to_http2_error. Send a RST_STREAM with this
@@ -455,6 +454,9 @@ typedef struct grpc_transport_op {
       nullptr;
   /// should the transport be disconnected
   grpc_error_handle disconnect_with_error;
+  /// should the transport go IDLE
+  /// (used only by client channel, only if disconnect_with_error is set)
+  bool go_idle = false;
   /// Start a graceful goaway with the specified error message. (The error code
   /// is ignored since graceful GOAWAYs use a NO_ERROR error code.) Use
   /// disconnect_with_error if graceful shutdown is not needed.

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

@@ -78,6 +78,8 @@ namespace {
 
 constexpr absl::string_view kPickFirst = "pick_first";
 
+// TODO(https://github.com/grpc/grpc/issues/40835): Remove metrics after 1.84.0
+// release. Metrics functionality was moved from pick_first to subchannel.
 const auto kMetricDisconnections =
     GlobalInstrumentsRegistry::RegisterUInt64Counter(
         "grpc.lb.pick_first.disconnections",

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

@@ -52,7 +52,6 @@
 #include <vector>
 
 #include "src/core/channelz/channelz.h"
-#include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/fake/fake_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -61,6 +60,8 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -76,6 +77,7 @@
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/telemetry/metrics.h"
+#include "src/core/telemetry/telemetry_label.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/dual_ref_counted.h"
@@ -146,6 +148,7 @@ const auto kMetricDefaultTargetPicks =
         "{pick}", false)
         .Labels(kMetricLabelTarget, kMetricLabelRlsServerTarget,
                 kMetricRlsDataPlaneTarget, kMetricLabelPickResult)
+        .OptionalLabels(kMetricLabelTelemetry)
         .Build();
 
 const auto kMetricTargetPicks =
@@ -158,6 +161,7 @@ const auto kMetricTargetPicks =
         "{pick}", false)
         .Labels(kMetricLabelTarget, kMetricLabelRlsServerTarget,
                 kMetricRlsDataPlaneTarget, kMetricLabelPickResult)
+        .OptionalLabels(kMetricLabelTelemetry)
         .Build();
 
 const auto kMetricFailedPicks =
@@ -167,6 +171,7 @@ const auto kMetricFailedPicks =
         "request or the RLS channel being throttled.",
         "{pick}", false)
         .Labels(kMetricLabelTarget, kMetricLabelRlsServerTarget)
+        .OptionalLabels(kMetricLabelTelemetry)
         .Build();
 
 const char kGrpc[] = "grpc";
@@ -696,7 +701,8 @@ class RlsLb final : public LoadBalancingPolicy {
   template <typename HandleType>
   void MaybeExportPickCount(HandleType handle, absl::string_view target,
                             absl::string_view lookup_service,
-                            const PickResult& pick_result);
+                            const PickResult& pick_result,
+                            absl::string_view telemetry_label);
 
   const std::string instance_uuid_;
 
@@ -1023,14 +1029,19 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
 
 LoadBalancingPolicy::PickResult RlsLb::Picker::PickFromDefaultTargetOrFail(
     const char* reason, PickArgs args, absl::Status status) {
+  absl::string_view telemetry_label;
+  if (auto* label = GetContext<Arena>()->GetContext<TelemetryLabel>();
+      label != nullptr) {
+    telemetry_label = label->value;
+  }
   if (default_child_policy_ != nullptr) {
     GRPC_TRACE_LOG(rls_lb, INFO)
         << "[rlslb " << lb_policy_.get() << "] picker=" << this << ": "
         << reason << "; using default target";
     auto pick_result = default_child_policy_->Pick(args);
-    lb_policy_->MaybeExportPickCount(kMetricDefaultTargetPicks,
-                                     config_->default_target(),
-                                     config_->lookup_service(), pick_result);
+    lb_policy_->MaybeExportPickCount(
+        kMetricDefaultTargetPicks, config_->default_target(),
+        config_->lookup_service(), pick_result, telemetry_label);
     return pick_result;
   }
   GRPC_TRACE_LOG(rls_lb, INFO)
@@ -1041,7 +1052,7 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::PickFromDefaultTargetOrFail(
   stats_plugins.AddCounter(kMetricFailedPicks, 1,
                            {lb_policy_->channel_control_helper()->GetTarget(),
                             config_->lookup_service()},
-                           {});
+                           {telemetry_label});
   return PickResult::Fail(std::move(status));
 }
 
@@ -1170,10 +1181,15 @@ LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(
       << child_policy_wrappers_.size() << ") in state "
       << ConnectivityStateName(child_policy_wrapper->connectivity_state())
       << "; delegating";
+  absl::string_view telemetry_label;
+  if (auto* label = GetContext<Arena>()->GetContext<TelemetryLabel>();
+      label != nullptr) {
+    telemetry_label = label->value;
+  }
   auto pick_result = child_policy_wrapper->Pick(args);
-  lb_policy_->MaybeExportPickCount(kMetricTargetPicks,
-                                   child_policy_wrapper->target(),
-                                   lookup_service, pick_result);
+  lb_policy_->MaybeExportPickCount(
+      kMetricTargetPicks, child_policy_wrapper->target(), lookup_service,
+      pick_result, telemetry_label);
   // Add header data.
   if (!header_data_.empty()) {
     auto* complete_pick =
@@ -2122,7 +2138,8 @@ void RlsLb::UpdatePickerLocked() {
 template <typename HandleType>
 void RlsLb::MaybeExportPickCount(HandleType handle, absl::string_view target,
                                  absl::string_view lookup_service,
-                                 const PickResult& pick_result) {
+                                 const PickResult& pick_result,
+                                 absl::string_view telemetry_label) {
   absl::string_view pick_result_string = Match(
       pick_result.result,
       [](const LoadBalancingPolicy::PickResult::Complete&) {
@@ -2136,7 +2153,7 @@ void RlsLb::MaybeExportPickCount(HandleType handle, absl::string_view target,
   stats_plugins.AddCounter(handle, 1,
                            {channel_control_helper()->GetTarget(),
                             lookup_service, target, pick_result_string},
-                           {});
+                           {telemetry_label});
 }
 
 //

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

@@ -80,18 +80,10 @@
 
 namespace grpc_core {
 
-bool WrrCustomMetricsEnabled() {
-  return IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_WRR_CUSTOM_METRICS");
-}
-
 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(
         "grpc.lb.wrr.rr_fallback",
@@ -220,41 +212,40 @@ void WeightedRoundRobinConfig::JsonPostLoad(const Json& json,
     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;
+  // Handle metricNamesForComputingUtilization.
+  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;
     }
   }
 }

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

@@ -30,8 +30,6 @@
 
 namespace grpc_core {
 
-bool WrrCustomMetricsEnabled();
-
 class WeightedRoundRobinConfig final : public LoadBalancingPolicy::Config {
  public:
   struct ParsedMetric {

data/src/core/load_balancing/xds/cds.cc

@@ -768,7 +768,9 @@ void CdsPriorityEndpointIterator::ForEach(
                 .SetObject(hierarchical_path_attr)
                 .Set(GRPC_ARG_ADDRESS_WEIGHT, endpoint_weight)
                 .SetObject(locality_name->Ref())
-                .Set(GRPC_ARG_XDS_LOCALITY_WEIGHT, locality.lb_weight);
+                .Set(GRPC_ARG_XDS_LOCALITY_WEIGHT, locality.lb_weight)
+                .Set(GRPC_ARG_LB_LOCALITY,
+                     locality_name->human_readable_string().as_string_view());
         if (!use_http_connect_) args = args.Remove(GRPC_ARG_XDS_HTTP_PROXY);
         callback(EndpointAddresses(endpoint.addresses(), args));
       }

data/src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -60,7 +60,6 @@
 #include "src/core/util/ref_counted_string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/validation_errors.h"
-#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
 #include "src/core/xds/grpc/xds_endpoint.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"

data/src/core/mitigation_engine/mitigation.h

@@ -25,19 +25,28 @@
 #include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/util/ref_counted.h"
 #include "absl/strings/string_view.h"
+#include "absl/time/time.h"
 
 namespace grpc_core {
 
 // Mitigations represent read-only configuration rules.
 class Mitigation : public RefCounted<Mitigation> {
  public:
+  struct EvaluationResult {
+    explicit EvaluationResult(MitigationEngine::Action action)
+        : action(action) {}
+
+    MitigationEngine::Action action;
+    bool reject_new_connections = false;
+    absl::Duration max_duration;
+    absl::string_view rule_name;
+  };
+
   ~Mitigation() override = default;
 
-  virtual std::optional<MitigationEngine::Action>
-  EvaluateIncomingMetadataParsed(absl::string_view key,
-                                 absl::string_view value) const = 0;
-  virtual std::optional<MitigationEngine::Action>
-  EvaluateIncomingMetadataAllParsed(
+  virtual std::optional<EvaluationResult> EvaluateIncomingMetadataParsed(
+      absl::string_view key, absl::string_view value) const = 0;
+  virtual std::optional<EvaluationResult> EvaluateIncomingMetadataAllParsed(
       const grpc_metadata_batch& metadata) const = 0;
 
   Mitigation() = default;

data/src/core/mitigation_engine/mitigation_engine.h

@@ -43,24 +43,28 @@ class MitigationEngine : public RefCounted<MitigationEngine> {
     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;
+      absl::string_view key, absl::string_view value,
+      absl::string_view peer_address) = 0;
+
   // Evaluates all incoming metadata after they have been parsed.
   virtual std::optional<Action> EvaluateAllIncomingMetadata(
-      const grpc_metadata_batch& metadata) = 0;
+      const grpc_metadata_batch& metadata, absl::string_view peer_address) = 0;
 };
 
 class MitigationEngineProvider
     : public DualRefCounted<MitigationEngineProvider> {
  public:
   static absl::string_view ChannelArgName() {
-    return "grpc.internal.mitigation_engine_provider";
+    return "grpc.mitigation_engine_provider";
   }
 
   static int ChannelArgsCompare(const MitigationEngineProvider* a,

data/src/core/mitigation_engine/mitigation_provider.h

@@ -40,7 +40,8 @@ class MitigationProvider {
 
   // Subscribes to mitigation configuration updates.
   //
-  // The provided callback is invoked whenever the mitigation rules change.
+  // The provided callback is invoked immediately with the current set of
+  // mitigations, and subsequently whenever the mitigation rules change.
   //
   // Returns an opaque MitigationSubscriptionHandle to be used as an
   // unsubscription token for CancelWatch().

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -20,13 +20,16 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/config/core_configuration.h"
+#include "src/core/ext/filters/channel_idle/legacy_channel_idle_filter.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 #include "src/core/handshaker/http_connect/http_connect_client_handshaker.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/server/server.h"
 #include "src/core/server/server_call_tracer_filter.h"
+#include "src/core/server/server_config_selector_filter.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -83,14 +86,42 @@ void RegisterBuiltins(CoreConfiguration::Builder* builder) {
   builder->channel_init()
       ->RegisterV2Filter<LameClientFilter>(GRPC_CLIENT_LAME_CHANNEL)
       .Terminal();
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &Server::kServerTopFilter)
-      .SkipV3()
-      .BeforeAll();
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_VIRTUAL_CHANNEL, &Server::kServerTopFilter)
-      .SkipV3()
-      .BeforeAll();
+
+  auto& top_filter_server_reg =
+      builder->channel_init()
+          ->RegisterFilter(GRPC_SERVER_CHANNEL, &Server::kServerTopFilter)
+          .SkipV3();
+
+  auto& top_filter_server_virtual_reg =
+      builder->channel_init()
+          ->RegisterFilter(GRPC_SERVER_VIRTUAL_CHANNEL,
+                           &Server::kServerTopFilter)
+          .SkipV3();
+
+  if (IsFixV3FilterStackServerSideOrderingEnabled()) {
+    top_filter_server_reg.SinkToBottom().After(
+        {LegacyMaxAgeFilter::kFilter.name});
+    top_filter_server_virtual_reg.SinkToBottom();
+  } else {
+    top_filter_server_reg.BeforeAll();
+    top_filter_server_virtual_reg.BeforeAll();
+  }
+
+  if (IsXdsServerFilterChainPerRouteEnabled()) {
+    auto& server_config_selector_interceptor_reg =
+        builder->channel_init()
+            ->RegisterFilter<ServerConfigSelectorInterceptor>(
+                GRPC_SERVER_CHANNEL)
+            .IfHasChannelArg(ServerConfigSelectorProvider::ChannelArgName());
+
+    if (IsFixV3FilterStackServerSideOrderingEnabled()) {
+      server_config_selector_interceptor_reg.Before(
+          {LegacyMaxAgeFilter::kFilter.name});
+    } else {
+      server_config_selector_interceptor_reg.After(
+          {LegacyMaxAgeFilter::kFilter.name});
+    }
+  }
 }
 
 }  // namespace