grpc 1.63.0 → 1.65.2

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

@@ -35,10 +35,10 @@
 #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/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 
 // Channel arg key for enabling parsing fault injection via method config.
 #define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -53,6 +54,7 @@ namespace grpc_core {
 
 const NoInterceptor HttpClientFilter::Call::OnServerToClientMessage;
 const NoInterceptor HttpClientFilter::Call::OnClientToServerMessage;
+const NoInterceptor HttpClientFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor HttpClientFilter::Call::OnFinalize;
 
 const grpc_channel_filter HttpClientFilter::kFilter =
@@ -136,16 +138,16 @@ HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,
                                    Slice user_agent,
                                    bool test_only_use_put_requests)
     : scheme_(scheme),
-      user_agent_(std::move(user_agent)),
-      test_only_use_put_requests_(test_only_use_put_requests) {}
+      test_only_use_put_requests_(test_only_use_put_requests),
+      user_agent_(std::move(user_agent)) {}
 
-absl::StatusOr<HttpClientFilter> HttpClientFilter::Create(
+absl::StatusOr<std::unique_ptr<HttpClientFilter>> HttpClientFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
   auto* transport = args.GetObject<Transport>();
   if (transport == nullptr) {
     return absl::InvalidArgumentError("HttpClientFilter needs a transport");
   }
-  return HttpClientFilter(
+  return std::make_unique<HttpClientFilter>(
       SchemeFromArgs(args),
       UserAgentFromArgs(args, transport->GetTransportName()),
       args.GetInt(GRPC_ARG_TEST_ONLY_USE_PUT_REQUESTS).value_or(false));

data/src/core/ext/filters/http/client/http_client_filter.h

@@ -35,26 +35,27 @@ class HttpClientFilter : public ImplementChannelFilter<HttpClientFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<HttpClientFilter> Create(
+  static absl::StatusOr<std::unique_ptr<HttpClientFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent,
+                   bool test_only_use_put_requests);
+
   class Call {
    public:
     void OnClientInitialMetadata(ClientMetadata& md, HttpClientFilter* filter);
     absl::Status OnServerInitialMetadata(ServerMetadata& md);
     absl::Status OnServerTrailingMetadata(ServerMetadata& md);
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
 
  private:
-  HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent,
-                   bool test_only_use_put_requests);
-
   HttpSchemeMetadata::ValueType scheme_;
-  Slice user_agent_;
   bool test_only_use_put_requests_;
+  Slice user_agent_;
 };
 
 // A test-only channel arg to allow testing gRPC Core server behavior on PUT

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -40,11 +40,12 @@ namespace grpc_core {
 const NoInterceptor ClientAuthorityFilter::Call::OnServerInitialMetadata;
 const NoInterceptor ClientAuthorityFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor ClientAuthorityFilter::Call::OnClientToServerMessage;
+const NoInterceptor ClientAuthorityFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ClientAuthorityFilter::Call::OnServerToClientMessage;
 const NoInterceptor ClientAuthorityFilter::Call::OnFinalize;
 
-absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
+absl::StatusOr<std::unique_ptr<ClientAuthorityFilter>>
+ClientAuthorityFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
   absl::optional<absl::string_view> default_authority =
       args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
   if (!default_authority.has_value()) {
@@ -52,7 +53,8 @@ absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
         "GRPC_ARG_DEFAULT_AUTHORITY string channel arg. not found. Note that "
         "direct channels must explicitly specify a value for this argument.");
   }
-  return ClientAuthorityFilter(Slice::FromCopiedString(*default_authority));
+  return std::make_unique<ClientAuthorityFilter>(
+      Slice::FromCopiedString(*default_authority));
 }
 
 void ClientAuthorityFilter::Call::OnClientInitialMetadata(

data/src/core/ext/filters/http/client_authority_filter.h

@@ -39,8 +39,11 @@ class ClientAuthorityFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ClientAuthorityFilter> Create(const ChannelArgs& args,
-                                                      ChannelFilter::Args);
+  static absl::StatusOr<std::unique_ptr<ClientAuthorityFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
+
+  explicit ClientAuthorityFilter(Slice default_authority)
+      : default_authority_(std::move(default_authority)) {}
 
   class Call {
    public:
@@ -49,13 +52,12 @@ class ClientAuthorityFilter final
     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 ClientAuthorityFilter(Slice default_authority)
-      : default_authority_(std::move(default_authority)) {}
   Slice default_authority_;
 };
 

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -22,6 +22,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -34,10 +35,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
-#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.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/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
@@ -50,14 +49,16 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 namespace grpc_core {
 
+const NoInterceptor ServerCompressionFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ServerCompressionFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor ServerCompressionFilter::Call::OnFinalize;
+const NoInterceptor ClientCompressionFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ClientCompressionFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor ClientCompressionFilter::Call::OnFinalize;
 
@@ -72,14 +73,14 @@ const grpc_channel_filter ServerCompressionFilter::kFilter =
                                kFilterExaminesInboundMessages |
                                kFilterExaminesOutboundMessages>("compression");
 
-absl::StatusOr<ClientCompressionFilter> ClientCompressionFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
-  return ClientCompressionFilter(args);
+absl::StatusOr<std::unique_ptr<ClientCompressionFilter>>
+ClientCompressionFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
+  return std::make_unique<ClientCompressionFilter>(args);
 }
 
-absl::StatusOr<ServerCompressionFilter> ServerCompressionFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
-  return ServerCompressionFilter(args);
+absl::StatusOr<std::unique_ptr<ServerCompressionFilter>>
+ServerCompressionFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
+  return std::make_unique<ServerCompressionFilter>(args);
 }
 
 ChannelCompression::ChannelCompression(const ChannelArgs& args)
@@ -112,13 +113,11 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
 
 MessageHandle ChannelCompression::CompressMessage(
     MessageHandle message, grpc_compression_algorithm algorithm) const {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
     gpr_log(GPR_INFO, "CompressMessage: len=%" PRIdPTR " alg=%d flags=%d",
             message->payload()->Length(), algorithm, message->flags());
   }
-  auto* call_context = GetContext<grpc_call_context_element>();
-  auto* call_tracer = static_cast<CallTracerInterface*>(
-      call_context[GRPC_CONTEXT_CALL_TRACER].value);
+  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordSendMessage(*message->payload());
   }
@@ -138,13 +137,13 @@ MessageHandle ChannelCompression::CompressMessage(
   // If we achieved compression send it as compressed, otherwise send it as (to
   // avoid spending cycles on the receiver decompressing).
   if (did_compress) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
       const size_t before_size = payload->Length();
       const size_t after_size = tmp.Length();
       const float savings_ratio = 1.0f - static_cast<float>(after_size) /
                                              static_cast<float>(before_size);
-      GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name));
+      CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       gpr_log(GPR_INFO,
               "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
               " bytes (%.2f%% savings)",
@@ -156,9 +155,9 @@ MessageHandle ChannelCompression::CompressMessage(
       call_tracer->RecordSendCompressedMessage(*message->payload());
     }
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
-      GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name));
+      CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       gpr_log(GPR_INFO,
               "Algorithm '%s' enabled but decided not to compress. Input size: "
               "%" PRIuPTR,
@@ -170,14 +169,12 @@ MessageHandle ChannelCompression::CompressMessage(
 
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     bool is_client, MessageHandle message, DecompressArgs args) const {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
     gpr_log(GPR_INFO, "DecompressMessage: len=%" PRIdPTR " max=%d alg=%d",
             message->payload()->Length(),
             args.max_recv_message_length.value_or(-1), args.algorithm);
   }
-  auto* call_context = GetContext<grpc_call_context_element>();
-  auto* call_tracer = static_cast<CallTracerInterface*>(
-      call_context[GRPC_CONTEXT_CALL_TRACER].value);
+  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordReceivedMessage(*message->payload());
   }
@@ -233,8 +230,7 @@ ChannelCompression::DecompressArgs ChannelCompression::HandleIncomingMetadata(
   auto max_recv_message_length = max_recv_size_;
   const MessageSizeParsedConfig* limits =
       MessageSizeParsedConfig::GetFromCallContext(
-          GetContext<grpc_call_context_element>(),
-          message_size_service_config_parser_index_);
+          GetContext<Arena>(), message_size_service_config_parser_index_);
   if (limits != nullptr && limits->max_recv_size().has_value() &&
       (!max_recv_message_length.has_value() ||
        *limits->max_recv_size() < *max_recv_message_length)) {

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -110,9 +110,12 @@ class ClientCompressionFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ClientCompressionFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ClientCompressionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  explicit ClientCompressionFilter(const ChannelArgs& args)
+      : compression_engine_(args) {}
+
   // Construct a promise for one call.
   class Call {
    public:
@@ -126,6 +129,7 @@ class ClientCompressionFilter final
     absl::StatusOr<MessageHandle> OnServerToClientMessage(
         MessageHandle message, ClientCompressionFilter* filter);
 
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnFinalize;
 
@@ -135,9 +139,6 @@ class ClientCompressionFilter final
   };
 
  private:
-  explicit ClientCompressionFilter(const ChannelArgs& args)
-      : compression_engine_(args) {}
-
   ChannelCompression compression_engine_;
 };
 
@@ -146,9 +147,12 @@ class ServerCompressionFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ServerCompressionFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ServerCompressionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  explicit ServerCompressionFilter(const ChannelArgs& args)
+      : compression_engine_(args) {}
+
   // Construct a promise for one call.
   class Call {
    public:
@@ -162,6 +166,7 @@ class ServerCompressionFilter final
     MessageHandle OnServerToClientMessage(MessageHandle message,
                                           ServerCompressionFilter* filter);
 
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnFinalize;
 
@@ -171,9 +176,6 @@ class ServerCompressionFilter final
   };
 
  private:
-  explicit ServerCompressionFilter(const ChannelArgs& args)
-      : compression_engine_(args) {}
-
   ChannelCompression compression_engine_;
 };
 

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -44,12 +44,12 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
 const NoInterceptor HttpServerFilter::Call::OnClientToServerMessage;
+const NoInterceptor HttpServerFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor HttpServerFilter::Call::OnServerToClientMessage;
 const NoInterceptor HttpServerFilter::Call::OnFinalize;
 
@@ -139,7 +139,7 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
 }
 
 void HttpServerFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
-  if (grpc_call_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(call)) {
     gpr_log(GPR_INFO, "%s[http-server] Write metadata",
             GetContext<Activity>()->DebugTag().c_str());
   }
@@ -152,9 +152,9 @@ void HttpServerFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
   FilterOutgoingMetadata(&md);
 }
 
-absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(
+absl::StatusOr<std::unique_ptr<HttpServerFilter>> HttpServerFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
-  return HttpServerFilter(
+  return std::make_unique<HttpServerFilter>(
       args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
       args.GetBool(
               GRPC_ARG_DO_NOT_USE_UNLESS_YOU_HAVE_PERMISSION_FROM_GRPC_TEAM_ALLOW_BROKEN_PUT_REQUESTS)

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -36,9 +36,13 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<HttpServerFilter> Create(
+  static absl::StatusOr<std::unique_ptr<HttpServerFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  HttpServerFilter(bool surface_user_agent, bool allow_put_requests)
+      : surface_user_agent_(surface_user_agent),
+        allow_put_requests_(allow_put_requests) {}
+
   class Call {
    public:
     ServerMetadataHandle OnClientInitialMetadata(ClientMetadata& md,
@@ -46,15 +50,12 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
     void OnServerInitialMetadata(ServerMetadata& md);
     void OnServerTrailingMetadata(ServerMetadata& md);
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
 
  private:
-  HttpServerFilter(bool surface_user_agent, bool allow_put_requests)
-      : surface_user_agent_(surface_user_agent),
-        allow_put_requests_(allow_put_requests) {}
-
   bool surface_user_agent_;
   bool allow_put_requests_;
 };

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -25,12 +25,10 @@
 
 #include "absl/strings/str_format.h"
 
-#include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/deadline/deadline_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -42,7 +40,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -53,10 +50,12 @@ namespace grpc_core {
 const NoInterceptor ClientMessageSizeFilter::Call::OnClientInitialMetadata;
 const NoInterceptor ClientMessageSizeFilter::Call::OnServerInitialMetadata;
 const NoInterceptor ClientMessageSizeFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ClientMessageSizeFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ClientMessageSizeFilter::Call::OnFinalize;
 const NoInterceptor ServerMessageSizeFilter::Call::OnClientInitialMetadata;
 const NoInterceptor ServerMessageSizeFilter::Call::OnServerInitialMetadata;
 const NoInterceptor ServerMessageSizeFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ServerMessageSizeFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ServerMessageSizeFilter::Call::OnFinalize;
 
 //
@@ -64,11 +63,8 @@ const NoInterceptor ServerMessageSizeFilter::Call::OnFinalize;
 //
 
 const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
-    const grpc_call_context_element* context,
-    size_t service_config_parser_index) {
-  if (context == nullptr) return nullptr;
-  auto* svc_cfg_call_data = static_cast<ServiceConfigCallData*>(
-      context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
+    Arena* arena, size_t service_config_parser_index) {
+  auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
   if (svc_cfg_call_data == nullptr) return nullptr;
   return static_cast<const MessageSizeParsedConfig*>(
       svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
@@ -142,19 +138,20 @@ const grpc_channel_filter ClientMessageSizeFilter::kFilter =
     MakePromiseBasedFilter<ClientMessageSizeFilter, FilterEndpoint::kClient,
                            kFilterExaminesOutboundMessages |
                                kFilterExaminesInboundMessages>("message_size");
+
 const grpc_channel_filter ServerMessageSizeFilter::kFilter =
     MakePromiseBasedFilter<ServerMessageSizeFilter, FilterEndpoint::kServer,
                            kFilterExaminesOutboundMessages |
                                kFilterExaminesInboundMessages>("message_size");
 
-absl::StatusOr<ClientMessageSizeFilter> ClientMessageSizeFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
-  return ClientMessageSizeFilter(args);
+absl::StatusOr<std::unique_ptr<ClientMessageSizeFilter>>
+ClientMessageSizeFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
+  return std::make_unique<ClientMessageSizeFilter>(args);
 }
 
-absl::StatusOr<ServerMessageSizeFilter> ServerMessageSizeFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
-  return ServerMessageSizeFilter(args);
+absl::StatusOr<std::unique_ptr<ServerMessageSizeFilter>>
+ServerMessageSizeFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
+  return std::make_unique<ServerMessageSizeFilter>(args);
 }
 
 namespace {
@@ -162,13 +159,13 @@ ServerMetadataHandle CheckPayload(const Message& msg,
                                   absl::optional<uint32_t> max_length,
                                   bool is_client, bool is_send) {
   if (!max_length.has_value()) return nullptr;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_call_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(call)) {
     gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
             GetContext<Activity>()->DebugTag().c_str(),
             is_send ? "send" : "recv", msg.payload()->Length(), *max_length);
   }
   if (msg.payload()->Length() <= *max_length) return nullptr;
-  auto r = GetContext<Arena>()->MakePooled<ServerMetadata>();
+  auto r = Arena::MakePooled<ServerMetadata>();
   r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
   r->Set(GrpcMessageMetadata(),
          Slice::FromCopiedString(absl::StrFormat(
@@ -187,8 +184,7 @@ ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
   // size to the receive limit.
   const MessageSizeParsedConfig* config_from_call_context =
       MessageSizeParsedConfig::GetFromCallContext(
-          GetContext<grpc_call_context_element>(),
-          filter->service_config_parser_index_);
+          GetContext<Arena>(), filter->service_config_parser_index_);
   if (config_from_call_context != nullptr) {
     absl::optional<uint32_t> max_send_size = limits_.max_send_size();
     absl::optional<uint32_t> max_recv_size = limits_.max_recv_size();
@@ -250,18 +246,10 @@ void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()
       ->RegisterFilter<ClientMessageSizeFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .ExcludeFromMinimalStack()
-      .If(HasMessageSizeLimits)
-      // TODO(ctiller): ordering constraint is here to match the ordering that
-      // existed prior to ordering constraints did. Re-examine the ordering of
-      // filters from first principles.
-      .Before({&grpc_client_deadline_filter});
+      .If(HasMessageSizeLimits);
   builder->channel_init()
       ->RegisterFilter<ServerMessageSizeFilter>(GRPC_SERVER_CHANNEL)
       .ExcludeFromMinimalStack()
-      .If(HasMessageSizeLimits)
-      // TODO(ctiller): ordering constraint is here to match the ordering that
-      // existed prior to ordering constraints did. Re-examine the ordering of
-      // filters from first principles.
-      .Before({&grpc_server_deadline_filter});
+      .If(HasMessageSizeLimits);
 }
 }  // namespace grpc_core

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -30,16 +30,15 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.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/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/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 
 namespace grpc_core {
 
@@ -55,8 +54,7 @@ class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
       : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
 
   static const MessageSizeParsedConfig* GetFromCallContext(
-      const grpc_call_context_element* context,
-      size_t service_config_parser_index);
+      Arena* arena, size_t service_config_parser_index);
 
   static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
 
@@ -91,9 +89,12 @@ class ServerMessageSizeFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ServerMessageSizeFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ServerMessageSizeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  explicit ServerMessageSizeFilter(const ChannelArgs& args)
+      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
+
   class Call {
    public:
     static const NoInterceptor OnClientInitialMetadata;
@@ -102,13 +103,12 @@ class ServerMessageSizeFilter final
     static const NoInterceptor OnFinalize;
     ServerMetadataHandle OnClientToServerMessage(
         const Message& message, ServerMessageSizeFilter* filter);
+    static const NoInterceptor OnClientToServerHalfClose;
     ServerMetadataHandle OnServerToClientMessage(
         const Message& message, ServerMessageSizeFilter* filter);
   };
 
  private:
-  explicit ServerMessageSizeFilter(const ChannelArgs& args)
-      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
   const MessageSizeParsedConfig parsed_config_;
 };
 
@@ -117,9 +117,12 @@ class ClientMessageSizeFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ClientMessageSizeFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ClientMessageSizeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
+  explicit ClientMessageSizeFilter(const ChannelArgs& args)
+      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
+
   class Call {
    public:
     explicit Call(ClientMessageSizeFilter* filter);
@@ -129,6 +132,7 @@ class ClientMessageSizeFilter final
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnFinalize;
     ServerMetadataHandle OnClientToServerMessage(const Message& message);
+    static const NoInterceptor OnClientToServerHalfClose;
     ServerMetadataHandle OnServerToClientMessage(const Message& message);
 
    private:
@@ -136,8 +140,6 @@ class ClientMessageSizeFilter final
   };
 
  private:
-  explicit ClientMessageSizeFilter(const ChannelArgs& args)
-      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
   const size_t service_config_parser_index_{MessageSizeParser::ParserIndex()};
   const MessageSizeParsedConfig parsed_config_;
 };

data/src/core/ext/filters/rbac/rbac_filter.cc

@@ -29,7 +29,6 @@
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/context.h"
@@ -46,16 +45,14 @@ namespace grpc_core {
 const NoInterceptor RbacFilter::Call::OnServerInitialMetadata;
 const NoInterceptor RbacFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor RbacFilter::Call::OnClientToServerMessage;
+const NoInterceptor RbacFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor RbacFilter::Call::OnServerToClientMessage;
 const NoInterceptor RbacFilter::Call::OnFinalize;
 
 absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
                                                        RbacFilter* filter) {
   // Fetch and apply the rbac policy from the service config.
-  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<RbacMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
           filter->service_config_parser_index_));
@@ -82,16 +79,21 @@ RbacFilter::RbacFilter(size_t index,
       service_config_parser_index_(RbacServiceConfigParser::ParserIndex()),
       per_channel_evaluate_args_(std::move(per_channel_evaluate_args)) {}
 
-absl::StatusOr<RbacFilter> RbacFilter::Create(const ChannelArgs& args,
-                                              ChannelFilter::Args filter_args) {
+absl::StatusOr<std::unique_ptr<RbacFilter>> RbacFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args filter_args) {
   auto* auth_context = args.GetObject<grpc_auth_context>();
   if (auth_context == nullptr) {
     return GRPC_ERROR_CREATE("No auth context found");
   }
-  return RbacFilter(grpc_channel_stack_filter_instance_number(
-                        filter_args.channel_stack(),
-                        filter_args.uninitialized_channel_element()),
-                    EvaluateArgs::PerChannelArgs(auth_context, args));
+  auto* transport = args.GetObject<Transport>();
+  if (transport == nullptr) {
+    // This should never happen since the transport is always set on the server
+    // side.
+    return GRPC_ERROR_CREATE("No transport configured");
+  }
+  return std::make_unique<RbacFilter>(
+      filter_args.instance_id(),
+      EvaluateArgs::PerChannelArgs(auth_context, args));
 }
 
 void RbacFilterRegister(CoreConfiguration::Builder* builder) {