grpc 1.63.0 → 1.65.2

data/src/core/client_channel/subchannel_pool_interface.h

@@ -27,17 +27,15 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 
 class Subchannel;
 
-extern TraceFlag grpc_subchannel_pool_trace;
-
 // A key that can uniquely identify a subchannel.
 class SubchannelKey final {
  public:
@@ -68,7 +66,7 @@ class SubchannelKey final {
 class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
  public:
   SubchannelPoolInterface()
-      : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_subchannel_pool_trace)
+      : RefCounted(GRPC_TRACE_FLAG_ENABLED(subchannel_pool)
                        ? "SubchannelPoolInterface"
                        : nullptr) {}
   ~SubchannelPoolInterface() override {}

data/src/core/client_channel/subchannel_stream_client.cc

@@ -23,11 +23,12 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #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"
@@ -35,6 +36,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/time_precise.h"
 
 #define SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define SUBCHANNEL_STREAM_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -57,12 +59,13 @@ SubchannelStreamClient::SubchannelStreamClient(
       connected_subchannel_(std::move(connected_subchannel)),
       interested_parties_(interested_parties),
       tracer_(tracer),
-      call_allocator_(
+      call_allocator_(MakeRefCounted<CallArenaAllocator>(
           connected_subchannel_->args()
               .GetObject<ResourceQuota>()
               ->memory_quota()
               ->CreateMemoryAllocator(
-                  (tracer != nullptr) ? tracer : "SubchannelStreamClient")),
+                  (tracer != nullptr) ? tracer : "SubchannelStreamClient"),
+          1024)),
       event_handler_(std::move(event_handler)),
       retry_backoff_(
           BackOff::Options()
@@ -74,22 +77,22 @@ SubchannelStreamClient::SubchannelStreamClient(
                   SUBCHANNEL_STREAM_RECONNECT_MAX_BACKOFF_SECONDS))),
       event_engine_(connected_subchannel_->args().GetObject<EventEngine>()) {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: created SubchannelStreamClient", tracer_, this);
+    LOG(INFO) << tracer_ << " " << this << ": created SubchannelStreamClient";
   }
   StartCall();
 }
 
 SubchannelStreamClient::~SubchannelStreamClient() {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: destroying SubchannelStreamClient", tracer_,
-            this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": destroying SubchannelStreamClient";
   }
 }
 
 void SubchannelStreamClient::Orphan() {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient shutting down", tracer_,
-            this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient shutting down";
   }
   {
     MutexLock lock(&mu_);
@@ -110,14 +113,15 @@ void SubchannelStreamClient::StartCall() {
 
 void SubchannelStreamClient::StartCallLocked() {
   if (event_handler_ == nullptr) return;
-  GPR_ASSERT(call_state_ == nullptr);
+  CHECK(call_state_ == nullptr);
   if (event_handler_ != nullptr) {
     event_handler_->OnCallStartLocked(this);
   }
   call_state_ = MakeOrphanable<CallState>(Ref(), interested_parties_);
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient created CallState %p",
-            tracer_, this, call_state_.get());
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient created CallState "
+              << call_state_.get();
   }
   call_state_->StartCallLocked();
 }
@@ -128,13 +132,13 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   }
   const Duration timeout = retry_backoff_.NextAttemptTime() - Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient health check call lost...",
-            tracer_, this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient health check call lost...";
     if (timeout > Duration::Zero()) {
-      gpr_log(GPR_INFO, "%s %p: ... will retry in %" PRId64 "ms.", tracer_,
-              this, timeout.millis());
+      LOG(INFO) << tracer_ << " " << this << ": ... will retry in "
+                << timeout.millis() << "ms.";
     } else {
-      gpr_log(GPR_INFO, "%s %p: ... retrying immediately.", tracer_, this);
+      LOG(INFO) << tracer_ << " " << this << ": ... retrying immediately.";
     }
   }
   retry_timer_handle_ = event_engine_->RunAfter(
@@ -151,9 +155,8 @@ void SubchannelStreamClient::OnRetryTimer() {
   if (event_handler_ != nullptr && retry_timer_handle_.has_value() &&
       call_state_ == nullptr) {
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
-      gpr_log(GPR_INFO,
-              "%s %p: SubchannelStreamClient restarting health check call",
-              tracer_, this);
+      LOG(INFO) << tracer_ << " " << this
+                << ": SubchannelStreamClient restarting health check call";
     }
     StartCallLocked();
   }
@@ -169,21 +172,13 @@ SubchannelStreamClient::CallState::CallState(
     grpc_pollset_set* interested_parties)
     : subchannel_stream_client_(std::move(health_check_client)),
       pollent_(grpc_polling_entity_create_from_pollset_set(interested_parties)),
-      arena_(Arena::Create(subchannel_stream_client_->connected_subchannel_
-                               ->GetInitialCallSizeEstimate(),
-                           &subchannel_stream_client_->call_allocator_)),
-      payload_(context_) {}
+      arena_(subchannel_stream_client_->call_allocator_->MakeArena()) {}
 
 SubchannelStreamClient::CallState::~CallState() {
   if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient destroying CallState %p",
-            subchannel_stream_client_->tracer_, subchannel_stream_client_.get(),
-            this);
-  }
-  for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
-    if (context_[i].destroy != nullptr) {
-      context_[i].destroy(context_[i].value);
-    }
+    LOG(INFO) << subchannel_stream_client_->tracer_ << " "
+              << subchannel_stream_client_.get()
+              << ": SubchannelStreamClient destroying CallState " << this;
   }
   // Unset the call combiner cancellation closure.  This has the
   // effect of scheduling the previously set cancellation closure, if
@@ -205,7 +200,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
       gpr_get_cycle_counter(),  // start_time
       Timestamp::InfFuture(),   // deadline
       arena_.get(),
-      context_,
       &call_combiner_,
   };
   grpc_error_handle error;
@@ -216,16 +210,14 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
   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,
-            StatusToString(error).c_str());
+    LOG(ERROR) << "SubchannelStreamClient " << subchannel_stream_client_.get()
+               << " CallState " << this << ": error creating "
+               << "stream on subchannel (" << StatusToString(error)
+               << "); will retry";
     CallEndedLocked(/*retry=*/true);
     return;
   }
   // Initialize payload and batch.
-  payload_.context = context_;
   batch_.payload = &payload_;
   // on_complete callback takes ref, handled manually.
   call_->Ref(DEBUG_LOCATION, "on_complete").release();
@@ -235,7 +227,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(error.ok());
+  CHECK(error.ok());
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
   batch_.send_initial_metadata = true;
@@ -369,12 +361,10 @@ void SubchannelStreamClient::CallState::RecvMessageReady() {
               subchannel_stream_client_.get(), recv_message_->JoinIntoString());
       if (!status.ok()) {
         if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
-          gpr_log(GPR_INFO,
-                  "%s %p: SubchannelStreamClient CallState %p: failed to "
-                  "parse response message: %s",
-                  subchannel_stream_client_->tracer_,
-                  subchannel_stream_client_.get(), this,
-                  status.ToString().c_str());
+          LOG(INFO) << subchannel_stream_client_->tracer_ << " "
+                    << subchannel_stream_client_.get()
+                    << ": SubchannelStreamClient CallState " << this
+                    << ": failed to parse response message: " << status;
         }
         Cancel();
       }
@@ -417,11 +407,10 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
                           nullptr /* error_string */);
   }
   if (GPR_UNLIKELY(self->subchannel_stream_client_->tracer_ != nullptr)) {
-    gpr_log(GPR_INFO,
-            "%s %p: SubchannelStreamClient CallState %p: health watch failed "
-            "with status %d",
-            self->subchannel_stream_client_->tracer_,
-            self->subchannel_stream_client_.get(), self, status);
+    LOG(INFO) << self->subchannel_stream_client_->tracer_ << " "
+              << self->subchannel_stream_client_.get()
+              << ": SubchannelStreamClient CallState " << self
+              << ": health watch failed with status " << status;
   }
   // Clean up.
   self->recv_trailing_metadata_.Clear();
@@ -444,7 +433,7 @@ void SubchannelStreamClient::CallState::CallEndedLocked(bool retry) {
   if (this == subchannel_stream_client_->call_state_.get()) {
     subchannel_stream_client_->call_state_.reset();
     if (retry) {
-      GPR_ASSERT(subchannel_stream_client_->event_handler_ != nullptr);
+      CHECK(subchannel_stream_client_->event_handler_ != nullptr);
       if (seen_response_.load(std::memory_order_acquire)) {
         // If the call fails after we've gotten a successful response, reset
         // the backoff and restart the call immediately.

data/src/core/client_channel/subchannel_stream_client.h

@@ -34,7 +34,6 @@
 
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -146,9 +145,8 @@ class SubchannelStreamClient final
     RefCountedPtr<SubchannelStreamClient> subchannel_stream_client_;
     grpc_polling_entity pollent_;
 
-    ScopedArenaPtr arena_;
+    RefCountedPtr<Arena> arena_;
     CallCombiner call_combiner_;
-    grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
 
     // The streaming call to the backend. Always non-null.
     // Refs are tracked manually; when the last ref is released, the
@@ -201,7 +199,7 @@ class SubchannelStreamClient final
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   grpc_pollset_set* interested_parties_;  // Do not own.
   const char* tracer_;
-  MemoryAllocator call_allocator_;
+  RefCountedPtr<CallArenaAllocator> call_allocator_;
 
   Mutex mu_;
   std::unique_ptr<CallEventHandler> event_handler_ ABSL_GUARDED_BY(mu_);

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -33,7 +33,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -46,11 +46,10 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_backend_metric_filter_trace(false, "backend_metric_filter");
-
 const NoInterceptor BackendMetricFilter::Call::OnClientInitialMetadata;
 const NoInterceptor BackendMetricFilter::Call::OnServerInitialMetadata;
 const NoInterceptor BackendMetricFilter::Call::OnClientToServerMessage;
+const NoInterceptor BackendMetricFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor BackendMetricFilter::Call::OnServerToClientMessage;
 const NoInterceptor BackendMetricFilter::Call::OnFinalize;
 
@@ -121,30 +120,29 @@ const grpc_channel_filter BackendMetricFilter::kFilter =
     MakePromiseBasedFilter<BackendMetricFilter, FilterEndpoint::kServer>(
         "backend_metric");
 
-absl::StatusOr<BackendMetricFilter> BackendMetricFilter::Create(
-    const ChannelArgs&, ChannelFilter::Args) {
-  return BackendMetricFilter();
+absl::StatusOr<std::unique_ptr<BackendMetricFilter>>
+BackendMetricFilter::Create(const ChannelArgs&, ChannelFilter::Args) {
+  return std::make_unique<BackendMetricFilter>();
 }
 
 void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
-  auto* ctx = &GetContext<
-      grpc_call_context_element>()[GRPC_CONTEXT_BACKEND_METRIC_PROVIDER];
+  if (md.get(GrpcCallWasCancelled()).value_or(false)) return;
+  auto* ctx = MaybeGetContext<BackendMetricProvider>();
   if (ctx == nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
       gpr_log(GPR_INFO, "[%p] No BackendMetricProvider.", this);
     }
     return;
   }
-  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(
-      reinterpret_cast<BackendMetricProvider*>(ctx->value));
+  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
   if (serialized.has_value() && !serialized->empty()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
       gpr_log(GPR_INFO, "[%p] Backend metrics serialized. size: %" PRIuPTR,
               this, serialized->size());
     }
     md.Set(EndpointLoadMetricsBinMetadata(),
            Slice::FromCopiedString(std::move(*serialized)));
-  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+  } else if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
     gpr_log(GPR_INFO, "[%p] No backend metrics.", this);
   }
 }

data/src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -35,8 +35,8 @@ class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<BackendMetricFilter> Create(const ChannelArgs& args,
-                                                    ChannelFilter::Args);
+  static absl::StatusOr<std::unique_ptr<BackendMetricFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
 
   class Call {
    public:
@@ -44,6 +44,7 @@ class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
     static const NoInterceptor OnServerInitialMetadata;
     void OnServerTrailingMetadata(ServerMetadata& md);
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };

data/src/core/ext/filters/backend_metrics/backend_metric_provider.h

@@ -15,6 +15,8 @@
 #ifndef GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H
 #define GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H
 
+#include "src/core/lib/resource_quota/arena.h"
+
 namespace grpc_core {
 
 struct BackendMetricData;
@@ -24,6 +26,11 @@ class BackendMetricProvider {
   virtual BackendMetricData GetBackendMetricData() = 0;
 };
 
+template <>
+struct ArenaContextType<BackendMetricProvider> {
+  static void Destroy(BackendMetricProvider*) {}
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H

data/src/core/ext/filters/census/grpc_context.cc

@@ -21,7 +21,6 @@
 #include <grpc/census.h>
 #include <grpc/grpc.h>
 
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
@@ -30,12 +29,11 @@ void grpc_census_call_set_context(grpc_call* call, census_context* context) {
   GRPC_API_TRACE("grpc_census_call_set_context(call=%p, census_context=%p)", 2,
                  (call, context));
   if (context != nullptr) {
-    grpc_call_context_set(call, GRPC_CONTEXT_TRACING, context, nullptr);
+    grpc_call_get_arena(call)->SetContext<census_context>(context);
   }
 }
 
 census_context* grpc_census_call_get_context(grpc_call* call) {
   GRPC_API_TRACE("grpc_census_call_get_context(call=%p)", 1, (call));
-  return static_cast<census_context*>(
-      grpc_call_context_get(call, GRPC_CONTEXT_TRACING));
+  return grpc_call_get_arena(call)->GetContext<census_context>();
 }

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -25,6 +25,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
+#include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
@@ -67,25 +68,20 @@ const auto kDefaultMaxConnectionAgeGrace = Duration::Infinity();
 const auto kDefaultMaxConnectionIdle = Duration::Infinity();
 const auto kMaxConnectionAgeJitter = 0.1;
 
-TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
 }  // namespace
 
 #define GRPC_IDLE_FILTER_LOG(format, ...)                               \
   do {                                                                  \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_client_idle_filter)) {       \
+    if (GRPC_TRACE_FLAG_ENABLED(client_idle_filter)) {                  \
       gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
     }                                                                   \
   } while (0)
 
-namespace {
-
 Duration GetClientIdleTimeout(const ChannelArgs& args) {
   return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
       .value_or(kDefaultIdleTimeout);
 }
 
-}  // namespace
-
 struct LegacyMaxAgeFilter::Config {
   Duration max_connection_age;
   Duration max_connection_idle;
@@ -128,19 +124,24 @@ struct LegacyMaxAgeFilter::Config {
   }
 };
 
-absl::StatusOr<LegacyClientIdleFilter> LegacyClientIdleFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args filter_args) {
-  LegacyClientIdleFilter filter(filter_args.channel_stack(),
-                                GetClientIdleTimeout(args));
-  return absl::StatusOr<LegacyClientIdleFilter>(std::move(filter));
+// We need access to the channel stack here to send a goaway - but that access
+// is deprecated and will be removed when call-v3 is fully enabled. This filter
+// will be removed at that time also, so just disable the deprecation warning
+// for now.
+ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
+absl::StatusOr<std::unique_ptr<LegacyClientIdleFilter>>
+LegacyClientIdleFilter::Create(const ChannelArgs& args,
+                               ChannelFilter::Args filter_args) {
+  return std::make_unique<LegacyClientIdleFilter>(filter_args.channel_stack(),
+                                                  GetClientIdleTimeout(args));
 }
 
-absl::StatusOr<LegacyMaxAgeFilter> LegacyMaxAgeFilter::Create(
+absl::StatusOr<std::unique_ptr<LegacyMaxAgeFilter>> LegacyMaxAgeFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args filter_args) {
-  LegacyMaxAgeFilter filter(filter_args.channel_stack(),
-                            Config::FromChannelArgs(args));
-  return absl::StatusOr<LegacyMaxAgeFilter>(std::move(filter));
+  return std::make_unique<LegacyMaxAgeFilter>(filter_args.channel_stack(),
+                                              Config::FromChannelArgs(args));
 }
+ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING
 
 void LegacyMaxAgeFilter::Shutdown() {
   max_age_activity_.Reset();

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.h

@@ -40,8 +40,15 @@
 
 namespace grpc_core {
 
+Duration GetClientIdleTimeout(const ChannelArgs& args);
+
 class LegacyChannelIdleFilter : public ChannelFilter {
  public:
+  LegacyChannelIdleFilter(grpc_channel_stack* channel_stack,
+                          Duration client_idle_timeout)
+      : channel_stack_(channel_stack),
+        client_idle_timeout_(client_idle_timeout) {}
+
   ~LegacyChannelIdleFilter() override = default;
 
   LegacyChannelIdleFilter(const LegacyChannelIdleFilter&) = delete;
@@ -59,11 +66,6 @@ class LegacyChannelIdleFilter : public ChannelFilter {
   using SingleSetActivityPtr =
       SingleSetPtr<Activity, typename ActivityPtr::deleter_type>;
 
-  LegacyChannelIdleFilter(grpc_channel_stack* channel_stack,
-                          Duration client_idle_timeout)
-      : channel_stack_(channel_stack),
-        client_idle_timeout_(client_idle_timeout) {}
-
   grpc_channel_stack* channel_stack() { return channel_stack_; };
 
   virtual void Shutdown();
@@ -94,10 +96,9 @@ class LegacyClientIdleFilter final : public LegacyChannelIdleFilter {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<LegacyClientIdleFilter> Create(
+  static absl::StatusOr<std::unique_ptr<LegacyClientIdleFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
- private:
   using LegacyChannelIdleFilter::LegacyChannelIdleFilter;
 };
 
@@ -106,9 +107,12 @@ class LegacyMaxAgeFilter final : public LegacyChannelIdleFilter {
   static const grpc_channel_filter kFilter;
   struct Config;
 
-  static absl::StatusOr<LegacyMaxAgeFilter> Create(
+  static absl::StatusOr<std::unique_ptr<LegacyMaxAgeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  LegacyMaxAgeFilter(grpc_channel_stack* channel_stack,
+                     const Config& max_age_config);
+
   void PostInit() override;
 
  private:
@@ -128,9 +132,6 @@ class LegacyMaxAgeFilter final : public LegacyChannelIdleFilter {
     LegacyMaxAgeFilter* filter_;
   };
 
-  LegacyMaxAgeFilter(grpc_channel_stack* channel_stack,
-                     const Config& max_age_config);
-
   void Shutdown() override;
 
   SingleSetActivityPtr max_age_activity_;

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

@@ -29,6 +29,7 @@
 
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -39,7 +40,6 @@
 
 #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"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -53,10 +53,10 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_fault_injection_filter_trace(false, "fault_injection_filter");
 const NoInterceptor FaultInjectionFilter::Call::OnServerInitialMetadata;
 const NoInterceptor FaultInjectionFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor FaultInjectionFilter::Call::OnClientToServerMessage;
+const NoInterceptor FaultInjectionFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor FaultInjectionFilter::Call::OnServerToClientMessage;
 const NoInterceptor FaultInjectionFilter::Call::OnFinalize;
 
@@ -135,24 +135,22 @@ class FaultInjectionFilter::InjectionDecision {
   FaultHandle active_fault_{false};
 };
 
-absl::StatusOr<FaultInjectionFilter> FaultInjectionFilter::Create(
-    const ChannelArgs&, ChannelFilter::Args filter_args) {
-  return FaultInjectionFilter(filter_args);
+absl::StatusOr<std::unique_ptr<FaultInjectionFilter>>
+FaultInjectionFilter::Create(const ChannelArgs&,
+                             ChannelFilter::Args filter_args) {
+  return std::make_unique<FaultInjectionFilter>(filter_args);
 }
 
 FaultInjectionFilter::FaultInjectionFilter(ChannelFilter::Args filter_args)
-    : index_(grpc_channel_stack_filter_instance_number(
-          filter_args.channel_stack(),
-          filter_args.uninitialized_channel_element())),
+    : index_(filter_args.instance_id()),
       service_config_parser_index_(
-          FaultInjectionServiceConfigParser::ParserIndex()),
-      mu_(new Mutex) {}
+          FaultInjectionServiceConfigParser::ParserIndex()) {}
 
 // Construct a promise for one call.
 ArenaPromise<absl::Status> FaultInjectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, FaultInjectionFilter* filter) {
   auto decision = filter->MakeInjectionDecision(md);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_fault_injection_filter_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(fault_injection_filter)) {
     gpr_log(GPR_INFO, "chand=%p: Fault injection triggered %s", this,
             decision.ToString().c_str());
   }
@@ -167,10 +165,7 @@ FaultInjectionFilter::MakeInjectionDecision(
     const ClientMetadata& initial_metadata) {
   // Fetch the fault injection policy from the service config, based on the
   // relative index for which policy should this CallData use.
-  auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
-      GetContext<
-          grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA]
-          .value);
+  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
   auto* method_params = static_cast<FaultInjectionMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
           service_config_parser_index_));
@@ -228,7 +223,7 @@ FaultInjectionFilter::MakeInjectionDecision(
   bool delay_request = delay != Duration::Zero();
   bool abort_request = abort_code != GRPC_STATUS_OK;
   if (delay_request || abort_request) {
-    MutexLock lock(mu_.get());
+    MutexLock lock(&mu_);
     if (delay_request) {
       delay_request =
           UnderFraction(&delay_rand_generator_, delay_percentage_numerator,

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

@@ -45,9 +45,11 @@ class FaultInjectionFilter
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<FaultInjectionFilter> Create(
+  static absl::StatusOr<std::unique_ptr<FaultInjectionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  explicit FaultInjectionFilter(ChannelFilter::Args filter_args);
+
   // Construct a promise for one call.
   class Call {
    public:
@@ -56,13 +58,12 @@ class FaultInjectionFilter
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
 
  private:
-  explicit FaultInjectionFilter(ChannelFilter::Args filter_args);
-
   class InjectionDecision;
   InjectionDecision MakeInjectionDecision(
       const ClientMetadata& initial_metadata);
@@ -70,7 +71,7 @@ class FaultInjectionFilter
   // The relative index of instances of the same filter.
   size_t index_;
   const size_t service_config_parser_index_;
-  std::unique_ptr<Mutex> mu_;
+  Mutex mu_;
   absl::InsecureBitGen abort_rand_generator_ ABSL_GUARDED_BY(mu_);
   absl::InsecureBitGen delay_rand_generator_ ABSL_GUARDED_BY(mu_);
 };