grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/filters/client_channel/retry_throttle.h

@@ -40,7 +40,8 @@ namespace internal {
 /// Tracks retry throttling data for an individual server name.
 class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
  public:
-  ServerRetryThrottleData(intptr_t max_milli_tokens, intptr_t milli_token_ratio,
+  ServerRetryThrottleData(uintptr_t max_milli_tokens,
+                          uintptr_t milli_token_ratio,
                           ServerRetryThrottleData* old_throttle_data);
   ~ServerRetryThrottleData() override;
 
@@ -50,15 +51,15 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
   /// Records a success.
   void RecordSuccess();
 
-  intptr_t max_milli_tokens() const { return max_milli_tokens_; }
-  intptr_t milli_token_ratio() const { return milli_token_ratio_; }
+  uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
+  uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
 
  private:
   void GetReplacementThrottleDataIfNeeded(
       ServerRetryThrottleData** throttle_data);
 
-  const intptr_t max_milli_tokens_;
-  const intptr_t milli_token_ratio_;
+  const uintptr_t max_milli_tokens_;
+  const uintptr_t milli_token_ratio_;
   gpr_atm milli_tokens_;
   // A pointer to the replacement for this ServerRetryThrottleData entry.
   // If non-nullptr, then this entry is stale and must not be used.
@@ -74,8 +75,8 @@ class ServerRetryThrottleMap {
   /// Returns the failure data for \a server_name, creating a new entry if
   /// needed.
   RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const std::string& server_name, intptr_t max_milli_tokens,
-      intptr_t milli_token_ratio);
+      const std::string& server_name, uintptr_t max_milli_tokens,
+      uintptr_t milli_token_ratio);
 
  private:
   using StringToDataMap =

data/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc

@@ -114,7 +114,7 @@ grpc_error_handle ServiceConfigChannelArgInitCallElem(
   }
   new (calld) ServiceConfigChannelArgCallData(std::move(service_config),
                                               method_config, args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void ServiceConfigChannelArgDestroyCallElem(
@@ -130,7 +130,7 @@ grpc_error_handle ServiceConfigChannelArgInitChannelElem(
   ServiceConfigChannelArgChannelData* chand =
       static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);
   new (chand) ServiceConfigChannelArgChannelData(args);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void ServiceConfigChannelArgDestroyChannelElem(grpc_channel_element* elem) {

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -43,18 +43,18 @@
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -81,7 +81,8 @@
                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)))
 
 namespace grpc_core {
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
+
+using ::grpc_event_engine::experimental::EventEngine;
 
 TraceFlag grpc_trace_subchannel(false, "subchannel");
 DebugOnlyTraceFlag grpc_trace_subchannel_refcount(false, "subchannel_refcount");
@@ -160,8 +161,8 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
-  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(*error))) {
-    gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
+  if (GPR_UNLIKELY(!error->ok())) {
+    gpr_log(GPR_ERROR, "error: %s", StatusToString(*error).c_str());
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
@@ -255,12 +256,11 @@ namespace {
 // Sets *status based on the rest of the parameters.
 void GetCallStatus(grpc_status_code* status, Timestamp deadline,
                    grpc_metadata_batch* md_batch, grpc_error_handle error) {
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
   } else {
     *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 }  // namespace
@@ -270,8 +270,7 @@ void SubchannelCall::RecvTrailingMetadataReady(void* arg,
   SubchannelCall* call = static_cast<SubchannelCall*>(arg);
   GPR_ASSERT(call->recv_trailing_metadata_ != nullptr);
   grpc_status_code status = GRPC_STATUS_OK;
-  GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_,
-                GRPC_ERROR_REF(error));
+  GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_, error);
   channelz::SubchannelNode* channelz_subchannel =
       call->connected_subchannel_->channelz_subchannel();
   GPR_ASSERT(channelz_subchannel != nullptr);
@@ -280,8 +279,7 @@ void SubchannelCall::RecvTrailingMetadataReady(void* arg,
   } else {
     channelz_subchannel->RecordCallFailed();
   }
-  Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_,
-               GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_, error);
 }
 
 void SubchannelCall::IncrementRefCount() {
@@ -365,7 +363,7 @@ class Subchannel::AsyncWatcherNotifierLocked {
                        delete self;
                      },
                      this, nullptr),
-                 GRPC_ERROR_NONE);
+                 absl::OkStatus());
   }
 
  private:
@@ -627,7 +625,8 @@ Subchannel::Subchannel(SubchannelKey key,
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
-      backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)) {
+      backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)),
+      event_engine_(args_.GetObjectRef<EventEngine>()) {
   // A grpc_init is added here to ensure that grpc_shutdown does not happen
   // until the subchannel is destroyed. Subchannels can persist longer than
   // channels because they maybe reused/shared among multiple channels. As a
@@ -637,7 +636,7 @@ Subchannel::Subchannel(SubchannelKey key,
   // triggering segmentation faults. To prevent this issue, we call a grpc_init
   // here and a grpc_shutdown in the subchannel destructor.
   InitInternally();
-  GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
+  global_stats().IncrementClientSubchannelsCreated();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
                     grpc_schedule_on_exec_ctx);
   // Check proxy mapper to determine address to connect to and channel
@@ -764,7 +763,7 @@ void Subchannel::ResetBackoff() {
   MutexLock lock(&mu_);
   backoff_.Reset();
   if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      GetDefaultEventEngine()->Cancel(retry_timer_handle_)) {
+      event_engine_->Cancel(retry_timer_handle_)) {
     OnRetryTimerLocked();
   } else if (state_ == GRPC_CHANNEL_CONNECTING) {
     next_attempt_time_ = Timestamp::Now();
@@ -889,14 +888,13 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
   WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
   {
     MutexLock lock(&c->mu_);
-    c->OnConnectingFinishedLocked(GRPC_ERROR_REF(error));
+    c->OnConnectingFinishedLocked(error);
   }
   c.reset(DEBUG_LOCATION, "Connect");
 }
 
 void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   if (shutdown_) {
-    (void)GRPC_ERROR_UNREF(error);
     return;
   }
   // If we didn't get a transport or we fail to publish it, report
@@ -910,11 +908,11 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
     gpr_log(GPR_INFO,
             "subchannel %p %s: connect failed (%s), backing off for %" PRId64
             " ms",
-            this, key_.ToString().c_str(), grpc_error_std_string(error).c_str(),
+            this, key_.ToString().c_str(), StatusToString(error).c_str(),
             time_until_next_attempt.millis());
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
-    retry_timer_handle_ = GetDefaultEventEngine()->RunAfter(
+    retry_timer_handle_ = event_engine_->RunAfter(
         time_until_next_attempt,
         [self = WeakRef(DEBUG_LOCATION, "RetryTimer")]() mutable {
           {
@@ -931,14 +929,13 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
           }
         });
   }
-  (void)GRPC_ERROR_UNREF(error);
 }
 
 bool Subchannel::PublishTransportLocked() {
   // Construct channel stack.
-  ChannelStackBuilderImpl builder("subchannel", GRPC_CLIENT_SUBCHANNEL);
-  builder.SetChannelArgs(connecting_result_.channel_args)
-      .SetTransport(connecting_result_.transport);
+  ChannelStackBuilderImpl builder("subchannel", GRPC_CLIENT_SUBCHANNEL,
+                                  connecting_result_.channel_args);
+  builder.SetTransport(connecting_result_.transport);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return false;
   }
@@ -948,8 +945,7 @@ bool Subchannel::PublishTransportLocked() {
     grpc_transport_destroy(connecting_result_.transport);
     gpr_log(GPR_ERROR,
             "subchannel %p %s: error initializing subchannel stack: %s", this,
-            key_.ToString().c_str(), grpc_error_std_string(error).c_str());
-    GRPC_ERROR_UNREF(error);
+            key_.ToString().c_str(), StatusToString(error).c_str());
     return false;
   }
   RefCountedPtr<channelz::SocketNode> socket =

data/src/core/ext/filters/client_channel/subchannel.h

@@ -24,6 +24,7 @@
 #include <deque>
 #include <functional>
 #include <map>
+#include <memory>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
@@ -239,8 +240,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
-  const ChannelArgs& channel_args() const { return args_; }
-
   channelz::SubchannelNode* channelz_node();
 
   // Starts watching the subchannel's connectivity state.
@@ -428,6 +427,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Data producer map.
   std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_
       ABSL_GUARDED_BY(mu_);
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/subchannel_stream_client.cc

@@ -30,6 +30,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -146,7 +147,7 @@ void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
   {
     MutexLock lock(&self->mu_);
     self->retry_timer_callback_pending_ = false;
-    if (self->event_handler_ != nullptr && GRPC_ERROR_IS_NONE(error) &&
+    if (self->event_handler_ != nullptr && error.ok() &&
         self->call_state_ == nullptr) {
       if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
         gpr_log(GPR_INFO,
@@ -196,7 +197,7 @@ SubchannelStreamClient::CallState::~CallState() {
 }
 
 void SubchannelStreamClient::CallState::Orphan() {
-  call_combiner_.Cancel(GRPC_ERROR_CANCELLED);
+  call_combiner_.Cancel(absl::CancelledError());
   Cancel();
 }
 
@@ -211,21 +212,19 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
       context_,
       &call_combiner_,
   };
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   call_ = SubchannelCall::Create(std::move(args), &error).release();
   // Register after-destruction callback.
   GRPC_CLOSURE_INIT(&after_call_stack_destruction_, AfterCallStackDestruction,
                     this, grpc_schedule_on_exec_ctx);
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
-  if (!GRPC_ERROR_IS_NONE(error) ||
-      subchannel_stream_client_->event_handler_ == nullptr) {
+  if (!error.ok() || subchannel_stream_client_->event_handler_ == nullptr) {
     gpr_log(GPR_ERROR,
             "SubchannelStreamClient %p CallState %p: error creating "
             "stream on subchannel (%s); will retry",
             subchannel_stream_client_.get(), this,
-            grpc_error_std_string(error).c_str());
-    GRPC_ERROR_UNREF(error);
+            StatusToString(error).c_str());
     CallEndedLocked(/*retry=*/true);
     return;
   }
@@ -240,7 +239,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
+  GPR_ASSERT(error.ok());
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
   payload_.send_initial_metadata.peer_string = nullptr;
@@ -306,7 +305,7 @@ void SubchannelStreamClient::CallState::StartBatch(
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, StartBatchInCallCombiner,
                     batch, grpc_schedule_on_exec_ctx);
   GRPC_CALL_COMBINER_START(&call_combiner_, &batch->handler_private.closure,
-                           GRPC_ERROR_NONE, "start_subchannel_batch");
+                           absl::OkStatus(), "start_subchannel_batch");
 }
 
 void SubchannelStreamClient::CallState::AfterCallStackDestruction(
@@ -328,7 +327,7 @@ void SubchannelStreamClient::CallState::StartCancel(
   auto* batch = grpc_make_transport_stream_op(
       GRPC_CLOSURE_CREATE(OnCancelComplete, self, grpc_schedule_on_exec_ctx));
   batch->cancel_stream = true;
-  batch->payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
+  batch->payload->cancel_stream.cancel_error = absl::CancelledError();
   self->call_->StartTransportStreamOpBatch(batch);
 }
 
@@ -341,7 +340,7 @@ void SubchannelStreamClient::CallState::Cancel() {
     GRPC_CALL_COMBINER_START(
         &call_combiner_,
         GRPC_CLOSURE_CREATE(StartCancel, this, grpc_schedule_on_exec_ctx),
-        GRPC_ERROR_NONE, "health_cancel");
+        absl::OkStatus(), "health_cancel");
   }
 }
 
@@ -418,7 +417,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   grpc_status_code status =
       self->recv_trailing_metadata_.get(GrpcStatusMetadata())
           .value_or(GRPC_STATUS_UNKNOWN);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_error_get_status(error, Timestamp::InfFuture(), &status,
                           nullptr /* slice */, nullptr /* http_error */,
                           nullptr /* error_string */);

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -31,6 +31,7 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -73,7 +74,7 @@ class TimerState {
     grpc_transport_stream_op_batch* batch = grpc_make_transport_stream_op(
         GRPC_CLOSURE_INIT(&self->closure_, YieldCallCombiner, self, nullptr));
     batch->cancel_stream = true;
-    batch->payload->cancel_stream.cancel_error = GRPC_ERROR_REF(error);
+    batch->payload->cancel_stream.cancel_error = error;
     self->elem_->filter->start_transport_stream_op_batch(self->elem_, batch);
   }
 
@@ -82,11 +83,11 @@ class TimerState {
     TimerState* self = static_cast<TimerState*>(arg);
     grpc_deadline_state* deadline_state =
         static_cast<grpc_deadline_state*>(self->elem_->call_data);
-    if (error != GRPC_ERROR_CANCELLED) {
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Deadline Exceeded"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_DEADLINE_EXCEEDED);
-      deadline_state->call_combiner->Cancel(GRPC_ERROR_REF(error));
+    if (error != absl::CancelledError()) {
+      error = grpc_error_set_int(GRPC_ERROR_CREATE("Deadline Exceeded"),
+                                 StatusIntProperty::kRpcStatus,
+                                 GRPC_STATUS_DEADLINE_EXCEEDED);
+      deadline_state->call_combiner->Cancel(error);
       GRPC_CLOSURE_INIT(&self->closure_, SendCancelOpInCallCombiner, self,
                         nullptr);
       GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &self->closure_,
@@ -145,7 +146,7 @@ static void recv_trailing_metadata_ready(void* arg, grpc_error_handle error) {
   // Invoke the original callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           deadline_state->original_recv_trailing_metadata_ready,
-                          GRPC_ERROR_REF(error));
+                          error);
 }
 
 // Inject our own recv_trailing_metadata_ready callback into op.
@@ -183,8 +184,7 @@ static void start_timer_after_init(void* arg, grpc_error_handle error) {
     // need to bounce ourselves into it.
     state->in_call_combiner = true;
     GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &state->closure,
-                             GRPC_ERROR_REF(error),
-                             "scheduling deadline timer");
+                             error, "scheduling deadline timer");
     return;
   }
   delete state;
@@ -212,7 +212,7 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
         new start_timer_after_init_state(elem, deadline);
     GRPC_CLOSURE_INIT(&state->closure, start_timer_after_init, state,
                       grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, absl::OkStatus());
   }
 }
 
@@ -249,7 +249,7 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
 static grpc_error_handle deadline_init_channel_elem(
     grpc_channel_element* /*elem*/, grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for channel_data.  Used for both client and server filters.
@@ -276,7 +276,7 @@ typedef struct server_call_data {
 static grpc_error_handle deadline_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) grpc_deadline_state(elem, *args, args->deadline);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for call_data.  Used for both client and server filters.
@@ -305,8 +305,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
                 .value_or(grpc_core::Timestamp::InfFuture()));
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->next_recv_initial_metadata_ready,
-                          GRPC_ERROR_REF(error));
+                          calld->next_recv_initial_metadata_ready, error);
 }
 
 // Method for starting a call op for server filter.

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -35,7 +35,7 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/fault_injection/service_config_parser.h"
+#include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/status_util.h"

data/src/core/ext/filters/fault_injection/fault_injection_filter.h

@@ -34,10 +34,6 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 
-// Channel arg key for enabling parsing fault injection via method config.
-#define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \
-  "grpc.parse_fault_injection_method_config"
-
 namespace grpc_core {
 
 // This channel filter is intended to be used by the dynamic filters, instead

data/src/core/ext/filters/fault_injection/fault_injection_service_config_parser.cc

@@ -0,0 +1,118 @@
+//
+// Copyright 2021 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/ext/filters/fault_injection/fault_injection_service_config_parser.h"
+
+#include <vector>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/status_util.h"
+
+namespace grpc_core {
+
+const JsonLoaderInterface*
+FaultInjectionMethodParsedConfig::FaultInjectionPolicy::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<FaultInjectionPolicy>()
+          .OptionalField("abortMessage", &FaultInjectionPolicy::abort_message)
+          .OptionalField("abortCodeHeader",
+                         &FaultInjectionPolicy::abort_code_header)
+          .OptionalField("abortPercentageHeader",
+                         &FaultInjectionPolicy::abort_percentage_header)
+          .OptionalField("abortPercentageNumerator",
+                         &FaultInjectionPolicy::abort_percentage_numerator)
+          .OptionalField("abortPercentageDenominator",
+                         &FaultInjectionPolicy::abort_percentage_denominator)
+          .OptionalField("delay", &FaultInjectionPolicy::delay)
+          .OptionalField("delayHeader", &FaultInjectionPolicy::delay_header)
+          .OptionalField("delayPercentageHeader",
+                         &FaultInjectionPolicy::delay_percentage_header)
+          .OptionalField("delayPercentageNumerator",
+                         &FaultInjectionPolicy::delay_percentage_numerator)
+          .OptionalField("delayPercentageDenominator",
+                         &FaultInjectionPolicy::delay_percentage_denominator)
+          .OptionalField("maxFaults", &FaultInjectionPolicy::max_faults)
+          .Finish();
+  return loader;
+}
+
+void FaultInjectionMethodParsedConfig::FaultInjectionPolicy::JsonPostLoad(
+    const Json& json, const JsonArgs& args, ValidationErrors* errors) {
+  // Parse abort_code.
+  auto abort_code_string = LoadJsonObjectField<std::string>(
+      json.object_value(), args, "abortCode", errors, /*required=*/false);
+  if (abort_code_string.has_value() &&
+      !grpc_status_code_from_string(abort_code_string->c_str(), &abort_code)) {
+    ValidationErrors::ScopedField field(errors, ".abortCode");
+    errors->AddError("failed to parse status code");
+  }
+  // Validate abort_percentage_denominator.
+  if (abort_percentage_denominator != 100 &&
+      abort_percentage_denominator != 10000 &&
+      abort_percentage_denominator != 1000000) {
+    ValidationErrors::ScopedField field(errors, ".abortPercentageDenominator");
+    errors->AddError("must be one of 100, 10000, or 1000000");
+  }
+  // Validate delay_percentage_denominator.
+  if (delay_percentage_denominator != 100 &&
+      delay_percentage_denominator != 10000 &&
+      delay_percentage_denominator != 1000000) {
+    ValidationErrors::ScopedField field(errors, ".delayPercentageDenominator");
+    errors->AddError("must be one of 100, 10000, or 1000000");
+  }
+}
+
+const JsonLoaderInterface* FaultInjectionMethodParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<FaultInjectionMethodParsedConfig>()
+          .OptionalField(
+              "faultInjectionPolicy",
+              &FaultInjectionMethodParsedConfig::fault_injection_policies_)
+          .Finish();
+  return loader;
+}
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+FaultInjectionServiceConfigParser::ParsePerMethodParams(
+    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
+  // Only parse fault injection policy if the following channel arg is present.
+  if (!args.GetBool(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG)
+           .value_or(false)) {
+    return nullptr;
+  }
+  // Parse fault injection policy from given Json
+  return LoadFromJson<std::unique_ptr<FaultInjectionMethodParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+void FaultInjectionServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<FaultInjectionServiceConfigParser>());
+}
+
+size_t FaultInjectionServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/fault_injection/{service_config_parser.h → fault_injection_service_config_parser.h}

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
-#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#ifndef GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,10 +25,8 @@
 #include <limits>
 #include <memory>
 #include <string>
-#include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/status.h>
@@ -36,9 +34,16 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
+// Channel arg key for enabling parsing fault injection via method config.
+#define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \
+  "grpc.internal.parse_fault_injection_method_config"
+
 namespace grpc_core {
 
 class FaultInjectionMethodParsedConfig
@@ -46,7 +51,7 @@ class FaultInjectionMethodParsedConfig
  public:
   struct FaultInjectionPolicy {
     grpc_status_code abort_code = GRPC_STATUS_OK;
-    std::string abort_message;
+    std::string abort_message = "Fault injected";
     std::string abort_code_header;
     std::string abort_percentage_header;
     uint32_t abort_percentage_numerator = 0;
@@ -60,11 +65,11 @@ class FaultInjectionMethodParsedConfig
 
     // By default, the max allowed active faults are unlimited.
     uint32_t max_faults = std::numeric_limits<uint32_t>::max();
-  };
 
-  explicit FaultInjectionMethodParsedConfig(
-      std::vector<FaultInjectionPolicy> fault_injection_policies)
-      : fault_injection_policies_(std::move(fault_injection_policies)) {}
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs&,
+                      ValidationErrors* errors);
+  };
 
   // Returns the fault injection policy at certain index.
   // There might be multiple fault injection policies functioning at the same
@@ -79,6 +84,8 @@ class FaultInjectionMethodParsedConfig
     return &fault_injection_policies_[index];
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
  private:
   std::vector<FaultInjectionPolicy> fault_injection_policies_;
 };
@@ -88,8 +95,9 @@ class FaultInjectionServiceConfigParser final
  public:
   absl::string_view name() const override { return parser_name(); }
   // Parses the per-method service config for fault injection filter.
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParsePerMethodParams(const ChannelArgs& args, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& args, const Json& json,
+      ValidationErrors* errors) override;
   // Returns the parser index for FaultInjectionServiceConfigParser.
   static size_t ParserIndex();
   // Registers FaultInjectionServiceConfigParser to ServiceConfigParser.
@@ -101,4 +109,4 @@ class FaultInjectionServiceConfigParser final
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H