grpc 1.53.0.pre2 → 1.54.0

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

@@ -20,14 +20,9 @@
 
 #include <string.h>
 
-#include "absl/types/optional.h"
-
-#include <grpc/grpc.h>
-
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/compression_filter.h"
 #include "src/core/ext/filters/http/server/http_server_filter.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -50,13 +45,7 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
           if (!is_building_http_like_transport(builder)) return true;
-          auto args = builder->channel_args();
-          const bool enable =
-              args.GetBool(GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION)
-                  .value_or(true) ||
-              args.GetBool(GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION)
-                  .value_or(true);
-          if (enable) builder->PrependFilter(filter);
+          builder->PrependFilter(filter);
           return true;
         });
   };

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

@@ -36,6 +36,7 @@
 #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"
@@ -113,6 +114,12 @@ MessageHandle CompressionFilter::CompressMessage(
     gpr_log(GPR_ERROR, "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);
+  if (call_tracer != nullptr) {
+    call_tracer->RecordSendMessage(*message->payload());
+  }
   // Check if we're allowed to compress this message
   // (apps might want to disable compression for certain messages to avoid
   // crime/beast like vulns).
@@ -143,6 +150,9 @@ MessageHandle CompressionFilter::CompressMessage(
     }
     tmp.Swap(payload);
     flags |= GRPC_WRITE_INTERNAL_COMPRESS;
+    if (call_tracer != nullptr) {
+      call_tracer->RecordSendCompressedMessage(*message->payload());
+    }
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
       const char* algo_name;
@@ -163,6 +173,12 @@ absl::StatusOr<MessageHandle> CompressionFilter::DecompressMessage(
             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);
+  if (call_tracer != nullptr) {
+    call_tracer->RecordReceivedMessage(*message->payload());
+  }
   // Check max message length.
   if (args.max_recv_message_length.has_value() &&
       message->payload()->Length() >
@@ -189,6 +205,9 @@ absl::StatusOr<MessageHandle> CompressionFilter::DecompressMessage(
   message->payload()->Swap(&decompressed_slices);
   message->mutable_flags() &= ~GRPC_WRITE_INTERNAL_COMPRESS;
   message->mutable_flags() |= GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
+  if (call_tracer != nullptr) {
+    call_tracer->RecordReceivedDecompressedMessage(*message->payload());
+  }
   return std::move(message);
 }
 
@@ -233,7 +252,7 @@ ArenaPromise<ServerMetadataHandle> ClientCompressionFilter::MakeCallPromise(
         return CompressMessage(std::move(message), compression_algorithm);
       });
   auto* decompress_args = GetContext<Arena>()->New<DecompressArgs>(
-      DecompressArgs{GRPC_COMPRESS_NONE, absl::nullopt});
+      DecompressArgs{GRPC_COMPRESS_ALGORITHMS_COUNT, absl::nullopt});
   auto* decompress_err =
       GetContext<Arena>()->New<Latch<ServerMetadataHandle>>();
   call_args.server_initial_metadata->InterceptAndMap(
@@ -254,8 +273,8 @@ ArenaPromise<ServerMetadataHandle> ClientCompressionFilter::MakeCallPromise(
         return std::move(*r);
       });
   // Run the next filter, and race it with getting an error from decompression.
-  return Race(next_promise_factory(std::move(call_args)),
-              decompress_err->Wait());
+  return Race(decompress_err->Wait(),
+              next_promise_factory(std::move(call_args)));
 }
 
 ArenaPromise<ServerMetadataHandle> ServerCompressionFilter::MakeCallPromise(
@@ -269,7 +288,8 @@ ArenaPromise<ServerMetadataHandle> ServerCompressionFilter::MakeCallPromise(
        this](MessageHandle message) -> absl::optional<MessageHandle> {
         auto r = DecompressMessage(std::move(message), decompress_args);
         if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_DEBUG, "DecompressMessage returned %s",
+          gpr_log(GPR_DEBUG, "%s[compression] DecompressMessage returned %s",
+                  Activity::current()->DebugTag().c_str(),
                   r.status().ToString().c_str());
         }
         if (!r.ok()) {
@@ -295,13 +315,9 @@ ArenaPromise<ServerMetadataHandle> ServerCompressionFilter::MakeCallPromise(
        this](MessageHandle message) -> absl::optional<MessageHandle> {
         return CompressMessage(std::move(message), *compression_algorithm);
       });
-  // Concurrently:
-  // - call the next filter
-  // - decompress incoming messages
-  // - wait for initial metadata to be sent, and then commence compression of
-  //   outgoing messages
-  return Race(next_promise_factory(std::move(call_args)),
-              decompress_err->Wait());
+  // Run the next filter, and race it with getting an error from decompression.
+  return Race(decompress_err->Wait(),
+              next_promise_factory(std::move(call_args)));
 }
 
 }  // namespace grpc_core

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

@@ -18,10 +18,13 @@
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 
+#include <inttypes.h>
+
+#include <functional>
 #include <initializer_list>
-#include <new>
+#include <string>
+#include <utility>
 
-#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/grpc.h>
@@ -32,21 +35,22 @@
 #include "src/core/lib/channel/channel_stack.h"
 #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/call_combiner.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config_call_data.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_init.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"
 
-static void recv_message_ready(void* user_data, grpc_error_handle error);
-static void recv_trailing_metadata_ready(void* user_data,
-                                         grpc_error_handle error);
-
 namespace grpc_core {
 
 //
@@ -124,251 +128,164 @@ size_t MessageSizeParser::ParserIndex() {
       parser_name());
 }
 
-}  // namespace grpc_core
-
-namespace {
-struct channel_data {
-  grpc_core::MessageSizeParsedConfig limits;
-  const size_t service_config_parser_index{
-      grpc_core::MessageSizeParser::ParserIndex()};
-};
+//
+// MessageSizeFilter
+//
 
-struct call_data {
-  call_data(grpc_call_element* elem, const channel_data& chand,
-            const grpc_call_element_args& args)
-      : call_combiner(args.call_combiner), limits(chand.limits) {
-    GRPC_CLOSURE_INIT(&recv_message_ready, ::recv_message_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      ::recv_trailing_metadata_ready, elem,
-                      grpc_schedule_on_exec_ctx);
-    // Get max sizes from channel data, then merge in per-method config values.
-    // Note: Per-method config is only available on the client, so we
-    // apply the max request size to the send limit and the max response
-    // size to the receive limit.
-    const grpc_core::MessageSizeParsedConfig* config_from_call_context =
-        grpc_core::MessageSizeParsedConfig::GetFromCallContext(
-            args.context, chand.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();
-      if (config_from_call_context->max_send_size().has_value() &&
-          (!max_send_size.has_value() ||
-           *config_from_call_context->max_send_size() < *max_send_size)) {
-        max_send_size = *config_from_call_context->max_send_size();
+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");
+
+class MessageSizeFilter::CallBuilder {
+ private:
+  auto Interceptor(uint32_t max_length, bool is_send) {
+    return [max_length, is_send,
+            err = err_](MessageHandle msg) -> absl::optional<MessageHandle> {
+      if (grpc_call_trace.enabled()) {
+        gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
+                Activity::current()->DebugTag().c_str(),
+                is_send ? "send" : "recv", msg->payload()->Length(),
+                max_length);
       }
-      if (config_from_call_context->max_recv_size().has_value() &&
-          (!max_recv_size.has_value() ||
-           *config_from_call_context->max_recv_size() < *max_recv_size)) {
-        max_recv_size = *config_from_call_context->max_recv_size();
+      if (msg->payload()->Length() > max_length) {
+        if (err->is_set()) return std::move(msg);
+        auto r = GetContext<Arena>()->MakePooled<ServerMetadata>(
+            GetContext<Arena>());
+        r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
+        r->Set(GrpcMessageMetadata(),
+               Slice::FromCopiedString(
+                   absl::StrFormat("%s message larger than max (%u vs. %d)",
+                                   is_send ? "Sent" : "Received",
+                                   msg->payload()->Length(), max_length)));
+        err->Set(std::move(r));
+        return absl::nullopt;
       }
-      limits = grpc_core::MessageSizeParsedConfig(max_send_size, max_recv_size);
-    }
+      return std::move(msg);
+    };
   }
 
-  ~call_data() {}
-
-  grpc_core::CallCombiner* call_combiner;
-  grpc_core::MessageSizeParsedConfig limits;
-  // Receive closures are chained: we inject this closure as the
-  // recv_message_ready up-call on transport_stream_op, and remember to
-  // call our next_recv_message_ready member after handling it.
-  grpc_closure recv_message_ready;
-  grpc_closure recv_trailing_metadata_ready;
-  // The error caused by a message that is too large, or absl::OkStatus()
-  grpc_error_handle error;
-  // Used by recv_message_ready.
-  absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
-  // Original recv_message_ready callback, invoked after our own.
-  grpc_closure* next_recv_message_ready = nullptr;
-  // Original recv_trailing_metadata callback, invoked after our own.
-  grpc_closure* original_recv_trailing_metadata_ready;
-  bool seen_recv_trailing_metadata = false;
-  grpc_error_handle recv_trailing_metadata_error;
-};
-
-}  // namespace
+ public:
+  explicit CallBuilder(const MessageSizeParsedConfig& limits)
+      : limits_(limits) {}
 
-// Callback invoked when we receive a message.  Here we check the max
-// receive message size.
-static void recv_message_ready(void* user_data, grpc_error_handle error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (calld->recv_message->has_value() &&
-      calld->limits.max_recv_size().has_value() &&
-      (*calld->recv_message)->Length() >
-          static_cast<size_t>(*calld->limits.max_recv_size())) {
-    grpc_error_handle new_error = grpc_error_set_int(
-        GRPC_ERROR_CREATE(absl::StrFormat(
-            "Received message larger than max (%u vs. %d)",
-            (*calld->recv_message)->Length(), *calld->limits.max_recv_size())),
-        grpc_core::StatusIntProperty::kRpcStatus,
-        GRPC_STATUS_RESOURCE_EXHAUSTED);
-    error = grpc_error_add_child(error, new_error);
-    calld->error = error;
+  template <typename T>
+  void AddSend(T* pipe_end) {
+    if (!limits_.max_send_size().has_value()) return;
+    pipe_end->InterceptAndMap(Interceptor(*limits_.max_send_size(), true));
   }
-  // Invoke the next callback.
-  grpc_closure* closure = calld->next_recv_message_ready;
-  calld->next_recv_message_ready = nullptr;
-  if (calld->seen_recv_trailing_metadata) {
-    // We might potentially see another RECV_MESSAGE op. In that case, we do not
-    // want to run the recv_trailing_metadata_ready closure again. The newer
-    // RECV_MESSAGE op cannot cause any errors since the transport has already
-    // invoked the recv_trailing_metadata_ready closure and all further
-    // RECV_MESSAGE ops will get null payloads.
-    calld->seen_recv_trailing_metadata = false;
-    GRPC_CALL_COMBINER_START(calld->call_combiner,
-                             &calld->recv_trailing_metadata_ready,
-                             calld->recv_trailing_metadata_error,
-                             "continue recv_trailing_metadata_ready");
+  template <typename T>
+  void AddRecv(T* pipe_end) {
+    if (!limits_.max_recv_size().has_value()) return;
+    pipe_end->InterceptAndMap(Interceptor(*limits_.max_recv_size(), false));
   }
-  grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
-}
 
-// Callback invoked on completion of recv_trailing_metadata
-// Notifies the recv_trailing_metadata batch of any message size failures
-static void recv_trailing_metadata_ready(void* user_data,
-                                         grpc_error_handle error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (calld->next_recv_message_ready != nullptr) {
-    calld->seen_recv_trailing_metadata = true;
-    calld->recv_trailing_metadata_error = error;
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner,
-                            "deferring recv_trailing_metadata_ready until "
-                            "after recv_message_ready");
-    return;
+  ArenaPromise<ServerMetadataHandle> Run(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) {
+    return Race(err_->Wait(), next_promise_factory(std::move(call_args)));
   }
-  error = grpc_error_add_child(error, calld->error);
-  // Invoke the next callback.
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->original_recv_trailing_metadata_ready, error);
-}
 
-// Start transport stream op.
-static void message_size_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  // Check max send message size.
-  if (op->send_message && calld->limits.max_send_size().has_value() &&
-      op->payload->send_message.send_message->Length() >
-          static_cast<size_t>(*calld->limits.max_send_size())) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        op,
-        grpc_error_set_int(GRPC_ERROR_CREATE(absl::StrFormat(
-                               "Sent message larger than max (%u vs. %d)",
-                               op->payload->send_message.send_message->Length(),
-                               *calld->limits.max_send_size())),
-                           grpc_core::StatusIntProperty::kRpcStatus,
-                           GRPC_STATUS_RESOURCE_EXHAUSTED),
-        calld->call_combiner);
-    return;
-  }
-  // Inject callback for receiving a message.
-  if (op->recv_message) {
-    calld->next_recv_message_ready =
-        op->payload->recv_message.recv_message_ready;
-    calld->recv_message = op->payload->recv_message.recv_message;
-    op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
-  }
-  // Inject callback for receiving trailing metadata.
-  if (op->recv_trailing_metadata) {
-    calld->original_recv_trailing_metadata_ready =
-        op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-    op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &calld->recv_trailing_metadata_ready;
-  }
-  // Chain to the next filter.
-  grpc_call_next_op(elem, op);
-}
+ private:
+  Latch<ServerMetadataHandle>* const err_ =
+      GetContext<Arena>()->ManagedNew<Latch<ServerMetadataHandle>>();
+  MessageSizeParsedConfig limits_;
+};
 
-// Constructor for call_data.
-static grpc_error_handle message_size_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  new (elem->call_data) call_data(elem, *chand, *args);
-  return absl::OkStatus();
+absl::StatusOr<ClientMessageSizeFilter> ClientMessageSizeFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
+  return ClientMessageSizeFilter(args);
 }
 
-// Destructor for call_data.
-static void message_size_destroy_call_elem(
-    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->~call_data();
+absl::StatusOr<ServerMessageSizeFilter> ServerMessageSizeFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
+  return ServerMessageSizeFilter(args);
 }
 
-// Constructor for channel_data.
-static grpc_error_handle message_size_init_channel_elem(
-    grpc_channel_element* elem, grpc_channel_element_args* args) {
-  GPR_ASSERT(!args->is_last);
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  new (chand) channel_data();
-  chand->limits = grpc_core::MessageSizeParsedConfig::GetFromChannelArgs(
-      args->channel_args);
-  return absl::OkStatus();
-}
+ArenaPromise<ServerMetadataHandle> ClientMessageSizeFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  // Get max sizes from channel data, then merge in per-method config values.
+  // Note: Per-method config is only available on the client, so we
+  // apply the max request size to the send limit and the max response
+  // size to the receive limit.
+  MessageSizeParsedConfig limits = this->limits();
+  const MessageSizeParsedConfig* config_from_call_context =
+      MessageSizeParsedConfig::GetFromCallContext(
+          GetContext<grpc_call_context_element>(),
+          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();
+    if (config_from_call_context->max_send_size().has_value() &&
+        (!max_send_size.has_value() ||
+         *config_from_call_context->max_send_size() < *max_send_size)) {
+      max_send_size = *config_from_call_context->max_send_size();
+    }
+    if (config_from_call_context->max_recv_size().has_value() &&
+        (!max_recv_size.has_value() ||
+         *config_from_call_context->max_recv_size() < *max_recv_size)) {
+      max_recv_size = *config_from_call_context->max_recv_size();
+    }
+    limits = MessageSizeParsedConfig(max_send_size, max_recv_size);
+  }
 
-// Destructor for channel_data.
-static void message_size_destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  chand->~channel_data();
+  CallBuilder b(limits);
+  b.AddSend(call_args.client_to_server_messages);
+  b.AddRecv(call_args.server_to_client_messages);
+  return b.Run(std::move(call_args), std::move(next_promise_factory));
 }
 
-const grpc_channel_filter grpc_message_size_filter = {
-    message_size_start_transport_stream_op_batch,
-    nullptr,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    message_size_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    message_size_destroy_call_elem,
-    sizeof(channel_data),
-    message_size_init_channel_elem,
-    grpc_channel_stack_no_post_init,
-    message_size_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "message_size"};
+ArenaPromise<ServerMetadataHandle> ServerMessageSizeFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  CallBuilder b(limits());
+  b.AddSend(call_args.server_to_client_messages);
+  b.AddRecv(call_args.client_to_server_messages);
+  return b.Run(std::move(call_args), std::move(next_promise_factory));
+}
 
+namespace {
 // Used for GRPC_CLIENT_SUBCHANNEL
-static bool maybe_add_message_size_filter_subchannel(
-    grpc_core::ChannelStackBuilder* builder) {
+bool MaybeAddMessageSizeFilterToSubchannel(ChannelStackBuilder* builder) {
   if (builder->channel_args().WantMinimalStack()) {
     return true;
   }
-  builder->PrependFilter(&grpc_message_size_filter);
+  builder->PrependFilter(&ClientMessageSizeFilter::kFilter);
   return true;
 }
 
-// Used for GRPC_CLIENT_DIRECT_CHANNEL and GRPC_SERVER_CHANNEL. Adds the filter
-// only if message size limits or service config is specified.
-static bool maybe_add_message_size_filter(
-    grpc_core::ChannelStackBuilder* builder) {
-  auto channel_args = builder->channel_args();
-  if (channel_args.WantMinimalStack()) {
+// Used for GRPC_CLIENT_DIRECT_CHANNEL and GRPC_SERVER_CHANNEL. Adds the
+// filter only if message size limits or service config is specified.
+auto MaybeAddMessageSizeFilter(const grpc_channel_filter* filter) {
+  return [filter](ChannelStackBuilder* builder) {
+    auto channel_args = builder->channel_args();
+    if (channel_args.WantMinimalStack()) {
+      return true;
+    }
+    MessageSizeParsedConfig limits =
+        MessageSizeParsedConfig::GetFromChannelArgs(channel_args);
+    const bool enable =
+        limits.max_send_size().has_value() ||
+        limits.max_recv_size().has_value() ||
+        channel_args.GetString(GRPC_ARG_SERVICE_CONFIG).has_value();
+    if (enable) builder->PrependFilter(filter);
     return true;
-  }
-  grpc_core::MessageSizeParsedConfig limits =
-      grpc_core::MessageSizeParsedConfig::GetFromChannelArgs(channel_args);
-  const bool enable =
-      limits.max_send_size().has_value() ||
-      limits.max_recv_size().has_value() ||
-      channel_args.GetString(GRPC_ARG_SERVICE_CONFIG).has_value();
-  if (enable) builder->PrependFilter(&grpc_message_size_filter);
-  return true;
+  };
 }
 
-namespace grpc_core {
+}  // namespace
 void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder) {
   MessageSizeParser::Register(builder);
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_message_size_filter_subchannel);
-  builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL,
-                                         GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                         maybe_add_message_size_filter);
-  builder->channel_init()->RegisterStage(GRPC_SERVER_CHANNEL,
+  builder->channel_init()->RegisterStage(GRPC_CLIENT_SUBCHANNEL,
                                          GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                         maybe_add_message_size_filter);
+                                         MaybeAddMessageSizeFilterToSubchannel);
+  builder->channel_init()->RegisterStage(
+      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      MaybeAddMessageSizeFilter(&ClientMessageSizeFilter::kFilter));
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      MaybeAddMessageSizeFilter(&ServerMessageSizeFilter::kFilter));
 }
 }  // namespace grpc_core

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

@@ -24,21 +24,22 @@
 
 #include <memory>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.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/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/service_config/service_config_parser.h"
-
-extern const grpc_channel_filter grpc_message_size_filter;
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -85,6 +86,50 @@ class MessageSizeParser : public ServiceConfigParser::Parser {
 absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
 absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
+class MessageSizeFilter : public ChannelFilter {
+ protected:
+  explicit MessageSizeFilter(const ChannelArgs& args)
+      : limits_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
+
+  class CallBuilder;
+
+  const MessageSizeParsedConfig& limits() const { return limits_; }
+
+ private:
+  MessageSizeParsedConfig limits_;
+};
+
+class ServerMessageSizeFilter final : public MessageSizeFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ServerMessageSizeFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  using MessageSizeFilter::MessageSizeFilter;
+};
+
+class ClientMessageSizeFilter final : public MessageSizeFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ClientMessageSizeFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  const size_t service_config_parser_index_{MessageSizeParser::ParserIndex()};
+  using MessageSizeFilter::MessageSizeFilter;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_MESSAGE_SIZE_MESSAGE_SIZE_FILTER_H

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -89,13 +89,14 @@ void MaybeUpdateServerInitialMetadata(
     absl::optional<absl::string_view> cookie_value,
     ServerMetadata* server_initial_metadata) {
   // Get peer string.
-  auto peer_string = server_initial_metadata->get(PeerString());
-  if (!peer_string.has_value()) return;  // Nothing we can do.
+  Slice* peer_string = server_initial_metadata->get_pointer(PeerString());
+  if (peer_string == nullptr) return;  // Nothing we can do.
   // If there was no cookie or if the address changed, set the cookie.
-  if (!cookie_value.has_value() || *peer_string != *cookie_value) {
-    std::vector<std::string> parts = {
-        absl::StrCat(*cookie_config->name, "=",
-                     absl::Base64Escape(*peer_string), "; HttpOnly")};
+  if (!cookie_value.has_value() ||
+      peer_string->as_string_view() != *cookie_value) {
+    std::vector<std::string> parts = {absl::StrCat(
+        *cookie_config->name, "=",
+        absl::Base64Escape(peer_string->as_string_view()), "; HttpOnly")};
     if (!cookie_config->path.empty()) {
       parts.emplace_back(absl::StrCat("Path=", cookie_config->path));
     }