grpc 1.81.1 → 1.83.0

data/src/core/telemetry/call_tracer.cc

@@ -18,6 +18,9 @@
 
 #include "src/core/telemetry/call_tracer.h"
 
+#include <grpc/event_engine/internal/write_event.h>
+
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <utility>
@@ -37,6 +40,7 @@
 #include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/time/time.h"
 #include "absl/types/span.h"
 
 namespace grpc_core {
@@ -91,6 +95,31 @@ ServerCallTracerFactory* g_server_call_tracer_factory_ = nullptr;
 const char* kServerCallTracerFactoryChannelArgName =
     "grpc.experimental.server_call_tracer_factory";
 
+class DelegatingTcpCallTracer final : public TcpCallTracer {
+ public:
+  explicit DelegatingTcpCallTracer(
+      std::vector<std::shared_ptr<TcpCallTracer>> tracers)
+      : tracers_(std::move(tracers)) {}
+
+  void RecordConnectionTuple(const IpAddress& local_addr,
+                             const IpAddress& peer_addr) override {
+    for (const auto& tracer : tracers_) {
+      tracer->RecordConnectionTuple(local_addr, peer_addr);
+    }
+  }
+
+  void RecordEvent(grpc_event_engine::experimental::internal::WriteEvent event,
+                   absl::Time time, size_t byte_offset,
+                   const std::vector<TcpEventMetric>& metrics) override {
+    for (const auto& tracer : tracers_) {
+      tracer->RecordEvent(event, time, byte_offset, metrics);
+    }
+  }
+
+ private:
+  const std::vector<std::shared_ptr<TcpCallTracer>> tracers_;
+};
+
 }  // namespace
 
 ServerCallTracerFactory* ServerCallTracerFactory::Get(
@@ -223,7 +252,15 @@ class DelegatingClientCallTracer : public ClientCallTracerInterface {
       }
     }
     std::shared_ptr<TcpCallTracer> StartNewTcpTrace() override {
-      return nullptr;
+      std::vector<std::shared_ptr<TcpCallTracer>> tcp_tracers;
+      for (auto* tracer : tracers_) {
+        if (auto tcp_tracer = tracer->StartNewTcpTrace()) {
+          tcp_tracers.push_back(std::move(tcp_tracer));
+        }
+      }
+      if (tcp_tracers.empty()) return nullptr;
+      if (tcp_tracers.size() == 1) return tcp_tracers[0];
+      return std::make_shared<DelegatingTcpCallTracer>(std::move(tcp_tracers));
     }
     void SetOptionalLabel(OptionalLabelKey key,
                           RefCountedStringValue value) override {
@@ -386,7 +423,17 @@ class DelegatingServerCallTracer : public ServerCallTracerInterface {
       tracer->RecordAnnotation(annotation);
     }
   }
-  std::shared_ptr<TcpCallTracer> StartNewTcpTrace() override { return nullptr; }
+  std::shared_ptr<TcpCallTracer> StartNewTcpTrace() override {
+    std::vector<std::shared_ptr<TcpCallTracer>> tcp_tracers;
+    for (auto* tracer : tracers_) {
+      if (auto tcp_tracer = tracer->StartNewTcpTrace()) {
+        tcp_tracers.push_back(std::move(tcp_tracer));
+      }
+    }
+    if (tcp_tracers.empty()) return nullptr;
+    if (tcp_tracers.size() == 1) return tcp_tracers[0];
+    return std::make_shared<DelegatingTcpCallTracer>(std::move(tcp_tracers));
+  }
   std::string TraceId() override { return tracers_[0]->TraceId(); }
   std::string SpanId() override { return tracers_[0]->SpanId(); }
   bool IsSampled() override { return tracers_[0]->IsSampled(); }

data/src/core/telemetry/call_tracer.h

@@ -206,6 +206,7 @@ class ClientCallTracerInterface : public CallTracerAnnotationInterface {
       kXdsServiceNamespace,  // not public
       kLocality,
       kBackendService,
+      kTelemetryLabel,
       kSize  // should be last
     };
 

data/src/core/telemetry/histogram.h

@@ -18,12 +18,10 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <optional>
 #include <vector>
 
 #include "src/core/util/grpc_check.h"
 #include "absl/log/log.h"
-#include "absl/strings/str_join.h"
 #include "absl/types/span.h"
 
 namespace grpc_core {
@@ -72,22 +70,21 @@ class LinearHistogramShape {
 
 class ExponentialHistogramShape {
  public:
-  ExponentialHistogramShape(int64_t max, size_t buckets)
-      : max_(max), buckets_(buckets) {
-    first_non_trivial_ = -1;
+  ExponentialHistogramShape(int64_t max, size_t buckets) {
     GRPC_CHECK_GT(max, 0);
-    GRPC_CHECK_LT(buckets, 1000000000u);
+    // Increase if needed. As of June 2026, the maximum we are using is 100.
+    // Note that the BucketFor has to do a binary search, so it's better to
+    // keep the number of buckets small.
+    GRPC_CHECK_LE(buckets, 512u);
     if (max <= static_cast<int64_t>(buckets)) {
       for (size_t i = 0; i < static_cast<size_t>(max); ++i) {
         bounds_.push_back(i + 1);
       }
-      first_non_trivial_ = max;
-      buckets_ = max;
+      buckets = max;
       return;
     }
-    int64_t first_bucket = std::ceil(std::pow(max, 1.0 / (buckets_ + 1)));
+    int64_t first_bucket = std::ceil(std::pow(max, 1.0 / (buckets + 1)));
     if (first_bucket <= 1) first_bucket = 1;
-    if (first_bucket != 1) first_non_trivial_ = 0;
     bounds_.push_back(first_bucket);
     while (bounds_.size() < buckets) {
       int64_t nextb;
@@ -101,38 +98,10 @@ class ExponentialHistogramShape {
       }
       if (nextb <= bounds_.back() + 1) {
         nextb = bounds_.back() + 1;
-      } else if (first_non_trivial_ == -1) {
-        first_non_trivial_ = bounds_.size();
       }
       bounds_.push_back(nextb);
     }
-    GRPC_CHECK_EQ(bounds_.size(), buckets_);
-    if (first_non_trivial_ == -1) {
-      first_non_trivial_ = max_;
-      offset_ = 0;
-      shift_ = 0;
-      return;
-    }
-    offset_ = DoubleToUint(first_non_trivial_);
-    for (shift_ = 63; shift_ > 0; --shift_) {
-      bool found_alias = false;
-      for (size_t i = first_non_trivial_ + 1; i < bounds_.size(); ++i) {
-        if ((DoubleToUint(bounds_[i]) - offset_) >> shift_ ==
-            (DoubleToUint(bounds_[i - 1]) - offset_) >> shift_) {
-          found_alias = true;
-          break;
-        }
-      }
-      if (!found_alias) {
-        break;
-      }
-    }
-    GRPC_CHECK_GE(shift_, 0u);
-    GRPC_CHECK_LT(shift_, 64u);
-    for (size_t i = 0; i <= (DoubleToUint(max_) - offset_) >> shift_; ++i) {
-      lookup_table_.push_back(
-          BucketInBoundsFor(bounds_, UintToDouble((i << shift_) + offset_)));
-    }
+    GRPC_CHECK_EQ(bounds_.size(), buckets);
   }
 
   ExponentialHistogramShape(const ExponentialHistogramShape&) = delete;
@@ -141,63 +110,15 @@ class ExponentialHistogramShape {
   ExponentialHistogramShape(ExponentialHistogramShape&&) = default;
   ExponentialHistogramShape& operator=(ExponentialHistogramShape&&) = default;
 
-  size_t buckets() const { return buckets_; }
+  size_t buckets() const { return bounds_.size(); }
   size_t BucketFor(int64_t value) const {
-    if (value >= max_) return buckets_ - 1;
-    if (value < first_non_trivial_) {
-      if (value < 0) return 0;
-      return value;
-    }
-    auto index = (DoubleToUint(value) - offset_) >> shift_;
-    size_t bucket = lookup_table_[index];
-    GRPC_DCHECK_LT(bucket, buckets_) << absl::StrJoin(lookup_table_, ",");
-    GRPC_DCHECK_LT(bucket, bounds_.size()) << absl::StrJoin(bounds_, ",");
-    while (bucket < bounds_.size() - 1 && value >= bounds_[bucket]) {
-      ++bucket;
-    }
-    while (bucket > 0 && value < bounds_[bucket - 1]) {
-      --bucket;
-    }
-    GRPC_DCHECK_LT(value, bounds_[bucket]);
-    return bucket;
+    return BucketInBoundsFor(bounds_, value);
   }
 
   HistogramBuckets bounds() const { return bounds_; }
-  absl::Span<const size_t> lookup_table() const { return lookup_table_; }
 
  private:
-  union DblUint {
-    double dbl;
-    uint64_t uint;
-  };
-
-  static double UintToDouble(uint64_t x) {
-    union DblUint {
-      double dbl;
-      uint64_t uint;
-    };
-    DblUint val;
-    val.uint = x;
-    return val.dbl;
-  }
-
-  static uint64_t DoubleToUint(double x) {
-    union DblUint {
-      double dbl;
-      uint64_t uint;
-    };
-    DblUint val;
-    val.dbl = x;
-    return val.uint;
-  }
-
-  int64_t max_;
-  int64_t first_non_trivial_;
-  uint64_t offset_;
-  uint64_t shift_;
-  std::vector<size_t> lookup_table_;
   std::vector<int64_t> bounds_;
-  size_t buckets_;
 };
 
 }  // namespace grpc_core

data/src/core/telemetry/instrument.h

@@ -742,27 +742,31 @@ struct Counter {
 
 // An InstrumentHandle is a handle to a single metric in an
 // instrument domain. It has a Shape (how the metric behaves).
-template <typename Shape, typename Domain>
+template <typename Shape, typename DomainTag>
 class InstrumentHandle {
  public:
+  constexpr InstrumentHandle() = default;
+
+  constexpr InstrumentHandle(
+      instrument_detail::QueryableDomain* instrument_domain,
+      const InstrumentMetadata::Description* description, Shape shape)
+      : instrument_domain_(instrument_domain),
+        offset_(description ? description->offset : 0),
+        shape_(std::move(shape)),
+        description_(description) {}
+
   absl::string_view name() const { return description_->name; }
   absl::string_view description() const { return description_->description; }
   absl::string_view unit() const { return description_->unit; }
   uint64_t offset() const { return offset_; }
 
  private:
-  friend Domain;
-
-  InstrumentHandle(Domain* instrument_domain,
-                   const InstrumentMetadata::Description* description,
-                   Shape shape)
-      : instrument_domain_(instrument_domain),
-        offset_(description->offset),
-        shape_(std::move(shape)),
-        description_(description) {}
+  friend class instrument_detail::QueryableDomain;
+  template <typename B, size_t N, typename T>
+  friend class instrument_detail::InstrumentDomainImpl;
 
-  Domain* instrument_domain_;
-  uint64_t offset_;
+  instrument_detail::QueryableDomain* instrument_domain_ = nullptr;
+  uint64_t offset_ = 0;
   GPR_NO_UNIQUE_ADDRESS Shape shape_;
   const InstrumentMetadata::Description* description_ = nullptr;
 };
@@ -917,34 +921,27 @@ template <typename Backend, size_t N, typename Tag>
 class InstrumentDomainImpl final : public QueryableDomain {
  public:
   using Self = InstrumentDomainImpl<Backend, N, Tag>;
-  using CounterHandle = InstrumentHandle<Counter, Self>;
+  using CounterHandle = InstrumentHandle<Counter, Tag>;
   using UpDownCounterHandle =
-      InstrumentHandle<InstrumentMetadata::UpDownCounterShape, Self>;
+      InstrumentHandle<InstrumentMetadata::UpDownCounterShape, Tag>;
   using DoubleGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Tag>;
   using IntGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::IntGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::IntGaugeShape, Tag>;
   using UintGaugeHandle =
-      InstrumentHandle<InstrumentMetadata::UintGaugeShape, Self>;
+      InstrumentHandle<InstrumentMetadata::UintGaugeShape, Tag>;
   template <typename Shape>
-  using HistogramHandle = InstrumentHandle<const Shape*, Self>;
+  using HistogramHandle = InstrumentHandle<const Shape*, Tag>;
 
   class GaugeSink {
    public:
     explicit GaugeSink(GaugeStorage& storage) : storage_(storage) {}
 
-    void Set(InstrumentHandle<InstrumentMetadata::DoubleGaugeShape, Self> g,
-             double x) {
+    void Set(DoubleGaugeHandle g, double x) {
       storage_.SetDouble(g.offset_, x);
     }
-    void Set(InstrumentHandle<InstrumentMetadata::IntGaugeShape, Self> g,
-             int64_t x) {
-      storage_.SetInt(g.offset_, x);
-    }
-    void Set(InstrumentHandle<InstrumentMetadata::UintGaugeShape, Self> g,
-             uint64_t x) {
-      storage_.SetUint(g.offset_, x);
-    }
+    void Set(IntGaugeHandle g, int64_t x) { storage_.SetInt(g.offset_, x); }
+    void Set(UintGaugeHandle g, uint64_t x) { storage_.SetUint(g.offset_, x); }
 
    private:
     GaugeStorage& storage_;
@@ -1139,6 +1136,23 @@ class InstrumentDomainImpl final : public QueryableDomain {
 template <class Derived>
 class InstrumentDomain {
  public:
+  using CounterHandle =
+      instrument_detail::InstrumentHandle<instrument_detail::Counter, Derived>;
+  using UpDownCounterHandle = instrument_detail::InstrumentHandle<
+      InstrumentMetadata::UpDownCounterShape, Derived>;
+  using DoubleGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::DoubleGaugeShape,
+                                          Derived>;
+  using IntGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::IntGaugeShape,
+                                          Derived>;
+  using UintGaugeHandle =
+      instrument_detail::InstrumentHandle<InstrumentMetadata::UintGaugeShape,
+                                          Derived>;
+  template <typename Shape>
+  using HistogramHandle =
+      instrument_detail::InstrumentHandle<const Shape*, Derived>;
+
   static auto* Domain() {
     static const auto labels = Derived::Labels();
     static auto* domain =

data/src/core/telemetry/tcp_tracer.h

@@ -19,10 +19,12 @@
 #ifndef GRPC_SRC_CORE_TELEMETRY_TCP_TRACER_H
 #define GRPC_SRC_CORE_TELEMETRY_TCP_TRACER_H
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/internal/write_event.h>
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
 
 #include <optional>
 #include <string>
@@ -126,6 +128,42 @@ class TcpCallTracer {
 
   virtual ~TcpCallTracer() = default;
 
+  struct IpAddress {
+    uint16_t family = 0;
+    uint16_t port = 0;
+    uint8_t ip[16] = {0};
+  };
+
+  virtual void RecordConnectionTuple(const IpAddress& local_addr,
+                                     const IpAddress& peer_addr) {}
+
+  static IpAddress ExtractResolvedAddress(
+      const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+          addr) {
+    IpAddress out;
+    const sockaddr* sa = addr.address();
+    if (sa == nullptr) {
+      out.family = 0;
+      out.port = 0;
+      memset(out.ip, 0, sizeof(out.ip));
+      return out;
+    }
+    out.family = sa->sa_family;
+    memset(out.ip, 0, sizeof(out.ip));
+    if (sa->sa_family == AF_INET) {
+      const sockaddr_in* addr4 = reinterpret_cast<const sockaddr_in*>(sa);
+      out.port = ntohs(addr4->sin_port);
+      memcpy(out.ip, &addr4->sin_addr.s_addr, 4);
+    } else if (sa->sa_family == AF_INET6) {
+      const sockaddr_in6* addr6 = reinterpret_cast<const sockaddr_in6*>(sa);
+      out.port = ntohs(addr6->sin6_port);
+      memcpy(out.ip, &addr6->sin6_addr.s6_addr, 16);
+    } else {
+      out.port = 0;
+    }
+    return out;
+  }
+
   // Records a per-message event with an optional snapshot of connection
   // metrics.
   virtual void RecordEvent(

data/src/core/transport/message_size_service_config.cc

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 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 "src/core/transport/message_size_service_config.h"
+
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/status.h>
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+
+#include "src/core/config/core_configuration.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/service_config/service_config_call_data.h"
+
+namespace grpc_core {
+
+//
+// MessageSizeParsedConfig
+//
+
+const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
+    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));
+}
+
+MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
+    const ChannelArgs& channel_args) {
+  MessageSizeParsedConfig limits;
+  limits.max_send_size_ = GetMaxSendSizeFromChannelArgs(channel_args);
+  limits.max_recv_size_ = GetMaxRecvSizeFromChannelArgs(channel_args);
+  return limits;
+}
+
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
+  if (size < 0) return std::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
+  if (args.WantMinimalStack()) return std::nullopt;
+  int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
+                 .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
+  if (size < 0) return std::nullopt;
+  return static_cast<uint32_t>(size);
+}
+
+const JsonLoaderInterface* MessageSizeParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<MessageSizeParsedConfig>()
+          .OptionalField("maxRequestMessageBytes",
+                         &MessageSizeParsedConfig::max_send_size_)
+          .OptionalField("maxResponseMessageBytes",
+                         &MessageSizeParsedConfig::max_recv_size_)
+          .Finish();
+  return loader;
+}
+
+//
+// MessageSizeParser
+//
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
+                                        const Json& json,
+                                        ValidationErrors* errors) {
+  return LoadFromJson<std::unique_ptr<MessageSizeParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<MessageSizeParser>());
+}
+
+size_t MessageSizeParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+std::optional<uint32_t> GetMaxRecvSizeFromCallContext(
+    Arena* arena, std::optional<uint32_t> max_recv_size_from_channel_args) {
+  const MessageSizeParsedConfig* config_from_call_context =
+      MessageSizeParsedConfig::GetFromCallContext(
+          arena, MessageSizeParser::ParserIndex());
+  if (config_from_call_context == nullptr) {
+    return max_recv_size_from_channel_args;
+  }
+
+  if (config_from_call_context->max_recv_size().has_value() &&
+      (!max_recv_size_from_channel_args.has_value() ||
+       *config_from_call_context->max_recv_size() <
+           *max_recv_size_from_channel_args)) {
+    return config_from_call_context->max_recv_size();
+  }
+  return max_recv_size_from_channel_args;
+}
+
+}  // namespace grpc_core

data/src/core/transport/message_size_service_config.h

@@ -0,0 +1,85 @@
+//
+// Copyright 2026 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.
+//
+
+#ifndef GRPC_SRC_CORE_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H
+#define GRPC_SRC_CORE_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+
+#include "src/core/config/core_configuration.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/resource_quota/arena.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"
+#include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
+ public:
+  std::optional<uint32_t> max_send_size() const { return max_send_size_; }
+  std::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
+
+  MessageSizeParsedConfig() = default;
+
+  MessageSizeParsedConfig(std::optional<uint32_t> max_send_size,
+                          std::optional<uint32_t> max_recv_size)
+      : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
+
+  static const MessageSizeParsedConfig* GetFromCallContext(
+      Arena* arena, size_t service_config_parser_index);
+
+  static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
+ private:
+  std::optional<uint32_t> max_send_size_;
+  std::optional<uint32_t> max_recv_size_;
+};
+
+class MessageSizeParser : public ServiceConfigParser::Parser {
+ public:
+  absl::string_view name() const override { return parser_name(); }
+
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& /*args*/, const Json& json,
+      ValidationErrors* errors) override;
+
+  static void Register(CoreConfiguration::Builder* builder);
+
+  static size_t ParserIndex();
+
+ private:
+  static absl::string_view parser_name() { return "message_size"; }
+};
+
+std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
+std::optional<uint32_t> GetMaxRecvSizeFromCallContext(
+    Arena* arena, std::optional<uint32_t> max_recv_size_from_channel_args);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_TRANSPORT_MESSAGE_SIZE_SERVICE_CONFIG_H