grpc 1.32.0 → 1.33.0.pre1

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

@@ -31,16 +31,17 @@
 namespace grpc_core {
 
 RefCountedPtr<ServiceConfig> ServiceConfig::Create(
-    absl::string_view json_string, grpc_error** error) {
+    const grpc_channel_args* args, absl::string_view json_string,
+    grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeRefCounted<ServiceConfig>(
-      std::string(json_string.data(), json_string.size()), std::move(json),
-      error);
+  return MakeRefCounted<ServiceConfig>(args, std::string(json_string),
+                                       std::move(json), error);
 }
 
-ServiceConfig::ServiceConfig(std::string json_string, Json json,
+ServiceConfig::ServiceConfig(const grpc_channel_args* args,
+                             std::string json_string, Json json,
                              grpc_error** error)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
@@ -52,9 +53,9 @@ ServiceConfig::ServiceConfig(std::string json_string, Json json,
   std::vector<grpc_error*> error_list;
   grpc_error* global_error = GRPC_ERROR_NONE;
   parsed_global_configs_ =
-      ServiceConfigParser::ParseGlobalParameters(json_, &global_error);
+      ServiceConfigParser::ParseGlobalParameters(args, json_, &global_error);
   if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
-  grpc_error* local_error = ParsePerMethodParams();
+  grpc_error* local_error = ParsePerMethodParams(args);
   if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
@@ -68,14 +69,15 @@ ServiceConfig::~ServiceConfig() {
   }
 }
 
-grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
+grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
+                                                 const Json& json) {
   std::vector<grpc_error*> error_list;
   // Parse method config with each registered parser.
   auto parsed_configs =
       absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
   grpc_error* parser_error = GRPC_ERROR_NONE;
   *parsed_configs =
-      ServiceConfigParser::ParsePerMethodParameters(json, &parser_error);
+      ServiceConfigParser::ParsePerMethodParameters(args, json, &parser_error);
   if (parser_error != GRPC_ERROR_NONE) {
     error_list.push_back(parser_error);
   }
@@ -128,7 +130,7 @@ grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error* ServiceConfig::ParsePerMethodParams() {
+grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
   std::vector<grpc_error*> error_list;
   auto it = json_.object_value().find("methodConfig");
   if (it != json_.object_value().end()) {
@@ -142,7 +144,7 @@ grpc_error* ServiceConfig::ParsePerMethodParams() {
             "field:methodConfig error:not of type Object"));
         continue;
       }
-      grpc_error* error = ParseJsonMethodConfig(method_config);
+      grpc_error* error = ParseJsonMethodConfig(args, method_config);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       }
@@ -202,15 +204,16 @@ std::string ServiceConfig::ParseJsonMethodName(const Json& json,
 
 const ServiceConfigParser::ParsedConfigVector*
 ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) const {
+  if (parsed_method_configs_map_.empty()) return nullptr;
   // Try looking up the full path in the map.
   auto it = parsed_method_configs_map_.find(path);
   if (it != parsed_method_configs_map_.end()) return it->second;
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/").
   UniquePtr<char> path_str(grpc_slice_to_c_string(path));
-  char* sep = strrchr(path_str.get(), '/') + 1;
+  char* sep = strrchr(path_str.get(), '/');
   if (sep == nullptr) return nullptr;  // Shouldn't ever happen.
-  *sep = '\0';
+  sep[1] = '\0';
   grpc_slice wildcard_path = grpc_slice_from_static_string(path_str.get());
   it = parsed_method_configs_map_.find(wildcard_path);
   if (it != parsed_method_configs_map_.end()) return it->second;

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

@@ -65,10 +65,12 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(absl::string_view json_string,
+  static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
+                                             absl::string_view json_string,
                                              grpc_error** error);
 
-  ServiceConfig(std::string json_string, Json json, grpc_error** error);
+  ServiceConfig(const grpc_channel_args* args, std::string json_string,
+                Json json, grpc_error** error);
   ~ServiceConfig();
 
   const std::string& json_string() const { return json_string_; }
@@ -89,8 +91,9 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
  private:
   // Helper functions for parsing the method configs.
-  grpc_error* ParsePerMethodParams();
-  grpc_error* ParseJsonMethodConfig(const Json& json);
+  grpc_error* ParsePerMethodParams(const grpc_channel_args* args);
+  grpc_error* ParseJsonMethodConfig(const grpc_channel_args* args,
+                                    const Json& json);
 
   // Returns a path string for the JSON name object specified by json.
   // Sets *error on error.

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

@@ -37,8 +37,8 @@ class ServiceConfigChannelArgChannelData {
         args->channel_args, GRPC_ARG_SERVICE_CONFIG);
     if (service_config_str != nullptr) {
       grpc_error* service_config_error = GRPC_ERROR_NONE;
-      auto service_config =
-          ServiceConfig::Create(service_config_str, &service_config_error);
+      auto service_config = ServiceConfig::Create(
+          args->channel_args, service_config_str, &service_config_error);
       if (service_config_error == GRPC_ERROR_NONE) {
         service_config_ = std::move(service_config);
       } else {

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

@@ -45,14 +45,15 @@ size_t ServiceConfigParser::RegisterParser(std::unique_ptr<Parser> parser) {
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParseGlobalParameters(const Json& json,
+ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
+                                           const Json& json,
                                            grpc_error** error) {
   ParsedConfigVector parsed_global_configs;
   std::vector<grpc_error*> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_config =
-        (*g_registered_parsers)[i]->ParseGlobalParams(json, &parser_error);
+    auto parsed_config = (*g_registered_parsers)[i]->ParseGlobalParams(
+        args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }
@@ -65,14 +66,15 @@ ServiceConfigParser::ParseGlobalParameters(const Json& json,
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParsePerMethodParameters(const Json& json,
+ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
+                                              const Json& json,
                                               grpc_error** error) {
   ParsedConfigVector parsed_method_configs;
   std::vector<grpc_error*> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_config =
-        (*g_registered_parsers)[i]->ParsePerMethodParams(json, &parser_error);
+    auto parsed_config = (*g_registered_parsers)[i]->ParsePerMethodParams(
+        args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }

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

@@ -23,6 +23,8 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
@@ -45,7 +47,7 @@ class ServiceConfigParser {
     virtual ~Parser() = default;
 
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -53,7 +55,7 @@ class ServiceConfigParser {
     }
 
     virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -77,11 +79,12 @@ class ServiceConfigParser {
   /// retrieved using the same index that was returned at registration time.
   static size_t RegisterParser(std::unique_ptr<Parser> parser);
 
-  static ParsedConfigVector ParseGlobalParameters(const Json& json,
+  static ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
+                                                  const Json& json,
                                                   grpc_error** error);
 
-  static ParsedConfigVector ParsePerMethodParameters(const Json& json,
-                                                     grpc_error** error);
+  static ParsedConfigVector ParsePerMethodParameters(
+      const grpc_channel_args* args, const Json& json, grpc_error** error);
 };
 
 }  // namespace grpc_core

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 
@@ -87,6 +88,49 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
 
   // TODO(roth): Need a better non-grpc-specific abstraction here.
   virtual const grpc_channel_args* channel_args() = 0;
+
+  // Allows accessing the attributes associated with the address for
+  // this subchannel.
+  virtual const ServerAddress::AttributeInterface* GetAttribute(
+      const char* key) const = 0;
+};
+
+// A class that delegates to another subchannel, to be used in cases
+// where an LB policy needs to wrap a subchannel.
+class DelegatingSubchannel : public SubchannelInterface {
+ public:
+  explicit DelegatingSubchannel(RefCountedPtr<SubchannelInterface> subchannel)
+      : wrapped_subchannel_(std::move(subchannel)) {}
+
+  RefCountedPtr<SubchannelInterface> wrapped_subchannel() const {
+    return wrapped_subchannel_;
+  }
+
+  grpc_connectivity_state CheckConnectivityState() override {
+    return wrapped_subchannel_->CheckConnectivityState();
+  }
+  void WatchConnectivityState(
+      grpc_connectivity_state initial_state,
+      std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override {
+    return wrapped_subchannel_->WatchConnectivityState(initial_state,
+                                                       std::move(watcher));
+  }
+  void CancelConnectivityStateWatch(
+      ConnectivityStateWatcherInterface* watcher) override {
+    return wrapped_subchannel_->CancelConnectivityStateWatch(watcher);
+  }
+  void AttemptToConnect() override { wrapped_subchannel_->AttemptToConnect(); }
+  void ResetBackoff() override { wrapped_subchannel_->ResetBackoff(); }
+  const grpc_channel_args* channel_args() override {
+    return wrapped_subchannel_->channel_args();
+  }
+  const ServerAddress::AttributeInterface* GetAttribute(
+      const char* key) const override {
+    return wrapped_subchannel_->GetAttribute(key);
+  }
+
+ private:
+  RefCountedPtr<SubchannelInterface> wrapped_subchannel_;
 };
 
 }  // namespace grpc_core

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

@@ -66,7 +66,8 @@ const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
 //
 
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
-MessageSizeParser::ParsePerMethodParams(const Json& json, grpc_error** error) {
+MessageSizeParser::ParsePerMethodParams(const grpc_channel_args* /*args*/,
+                                        const Json& json, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   std::vector<grpc_error*> error_list;
   // Max request size.

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

@@ -50,7 +50,8 @@ class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
 class MessageSizeParser : public ServiceConfigParser::Parser {
  public:
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const Json& json, grpc_error** error) override;
+      const grpc_channel_args* /*args*/, const Json& json,
+      grpc_error** error) override;
 
   static void Register();
 

data/src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -140,7 +140,6 @@ static void post_destructive_reclaimer(grpc_chttp2_transport* t);
 static void close_transport_locked(grpc_chttp2_transport* t, grpc_error* error);
 static void end_all_the_calls(grpc_chttp2_transport* t, grpc_error* error);
 
-static void schedule_bdp_ping_locked(grpc_chttp2_transport* t);
 static void start_bdp_ping(void* tp, grpc_error* error);
 static void finish_bdp_ping(void* tp, grpc_error* error);
 static void start_bdp_ping_locked(void* tp, grpc_error* error);
@@ -511,8 +510,7 @@ grpc_chttp2_transport::grpc_chttp2_transport(
   init_keepalive_pings_if_enabled(this);
 
   if (enable_bdp) {
-    GRPC_CHTTP2_REF_TRANSPORT(this, "bdp_ping");
-    schedule_bdp_ping_locked(this);
+    bdp_ping_blocked = true;
     grpc_chttp2_act_on_flowctl_action(flow_control->PeriodicUpdate(), this,
                                       nullptr);
   }
@@ -859,6 +857,9 @@ static void inc_initiate_write_reason(
     case GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING:
       GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_APPLICATION_PING();
       break;
+    case GRPC_CHTTP2_INITIATE_WRITE_BDP_PING:
+      GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING();
+      break;
     case GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING:
       GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_KEEPALIVE_PING();
       break;
@@ -2495,11 +2496,6 @@ static void read_action_locked(void* tp, grpc_error* error) {
     grpc_error* errors[3] = {GRPC_ERROR_REF(error), GRPC_ERROR_NONE,
                              GRPC_ERROR_NONE};
     for (; i < t->read_buffer.count && errors[1] == GRPC_ERROR_NONE; i++) {
-      grpc_core::BdpEstimator* bdp_est = t->flow_control->bdp_estimator();
-      if (bdp_est) {
-        bdp_est->AddIncomingBytes(
-            static_cast<int64_t> GRPC_SLICE_LENGTH(t->read_buffer.slices[i]));
-      }
       errors[1] = grpc_chttp2_perform_read(t, t->read_buffer.slices[i]);
     }
     if (errors[1] != GRPC_ERROR_NONE) {
@@ -2578,7 +2574,7 @@ static void continue_read_action_locked(grpc_chttp2_transport* t) {
 
 // t is reffed prior to calling the first time, and once the callback chain
 // that kicks off finishes, it's unreffed
-static void schedule_bdp_ping_locked(grpc_chttp2_transport* t) {
+void schedule_bdp_ping_locked(grpc_chttp2_transport* t) {
   t->flow_control->bdp_estimator()->SchedulePing();
   send_ping_locked(
       t,
@@ -2586,6 +2582,9 @@ static void schedule_bdp_ping_locked(grpc_chttp2_transport* t) {
                         grpc_schedule_on_exec_ctx),
       GRPC_CLOSURE_INIT(&t->finish_bdp_ping_locked, finish_bdp_ping, t,
                         grpc_schedule_on_exec_ctx));
+  // TODO(yashykt): Enabling this causes internal b/168345569. Re-enable once
+  // fixed.
+  // grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_BDP_PING);
 }
 
 static void start_bdp_ping(void* tp, grpc_error* error) {
@@ -2665,7 +2664,13 @@ static void next_bdp_ping_timer_expired_locked(void* tp, grpc_error* error) {
     GRPC_CHTTP2_UNREF_TRANSPORT(t, "bdp_ping");
     return;
   }
-  schedule_bdp_ping_locked(t);
+  if (t->flow_control->bdp_estimator()->accumulator() == 0) {
+    // Block the bdp ping till we receive more data.
+    t->bdp_ping_blocked = true;
+    GRPC_CHTTP2_UNREF_TRANSPORT(t, "bdp_ping");
+  } else {
+    schedule_bdp_ping_locked(t);
+  }
 }
 
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
@@ -3261,6 +3266,8 @@ const char* grpc_chttp2_initiate_write_reason_string(
       return "FLOW_CONTROL_UNSTALLED_BY_UPDATE";
     case GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING:
       return "APPLICATION_PING";
+    case GRPC_CHTTP2_INITIATE_WRITE_BDP_PING:
+      return "BDP_PING";
     case GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING:
       return "KEEPALIVE_PING";
     case GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED:

data/src/core/ext/transport/chttp2/transport/flow_control.cc

@@ -40,6 +40,9 @@ grpc_core::TraceFlag grpc_flowctl_trace(false, "flowctl");
 namespace grpc_core {
 namespace chttp2 {
 
+TestOnlyTransportTargetWindowEstimatesMocker*
+    g_test_only_transport_target_window_estimates_mocker;
+
 namespace {
 
 static constexpr const int kTracePadding = 30;
@@ -355,8 +358,13 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
     // target might change based on how much memory pressure we are under
     // TODO(ncteisen): experiment with setting target to be huge under low
     // memory pressure.
-    const double target = pow(2, SmoothLogBdp(TargetLogBdp()));
-
+    double target = pow(2, SmoothLogBdp(TargetLogBdp()));
+    if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
+      // Hook for simulating unusual flow control situations in tests.
+      target = g_test_only_transport_target_window_estimates_mocker
+                   ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+                       target_initial_window_size_ /* current target */);
+    }
     // Though initial window 'could' drop to 0, we keep the floor at 128
     target_initial_window_size_ =
         static_cast<int32_t> GPR_CLAMP(target, 128, INT32_MAX);

data/src/core/ext/transport/chttp2/transport/flow_control.h

@@ -466,6 +466,16 @@ class StreamFlowControl final : public StreamFlowControlBase {
   }
 };
 
+class TestOnlyTransportTargetWindowEstimatesMocker {
+ public:
+  virtual ~TestOnlyTransportTargetWindowEstimatesMocker() {}
+  virtual double ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+      double current_target) = 0;
+};
+
+extern TestOnlyTransportTargetWindowEstimatesMocker*
+    g_test_only_transport_target_window_estimates_mocker;
+
 }  // namespace chttp2
 }  // namespace grpc_core
 

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -101,6 +101,7 @@ typedef enum {
   GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_SETTING,
   GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_UPDATE,
   GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING,
+  GRPC_CHTTP2_INITIATE_WRITE_BDP_PING,
   GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING,
   GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED,
   GRPC_CHTTP2_INITIATE_WRITE_PING_RESPONSE,
@@ -434,6 +435,8 @@ struct grpc_chttp2_transport {
   grpc_chttp2_write_cb* write_cb_pool = nullptr;
 
   /* bdp estimator */
+  bool bdp_ping_blocked =
+      false; /* Is the BDP blocked due to not receiving any data? */
   grpc_closure next_bdp_ping_timer_expired_locked;
   grpc_closure start_bdp_ping_locked;
   grpc_closure finish_bdp_ping_locked;
@@ -878,4 +881,6 @@ void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
 
 void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error* error);
 
+void schedule_bdp_ping_locked(grpc_chttp2_transport* t);
+
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H */

data/src/core/ext/transport/chttp2/transport/parsing.cc

@@ -334,6 +334,16 @@ void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
 }
 
 static grpc_error* init_data_frame_parser(grpc_chttp2_transport* t) {
+  // Update BDP accounting since we have received a data frame.
+  grpc_core::BdpEstimator* bdp_est = t->flow_control->bdp_estimator();
+  if (bdp_est) {
+    if (t->bdp_ping_blocked) {
+      t->bdp_ping_blocked = false;
+      GRPC_CHTTP2_REF_TRANSPORT(t, "bdp_ping");
+      schedule_bdp_ping_locked(t);
+    }
+    bdp_est->AddIncomingBytes(t->incoming_frame_size);
+  }
   grpc_chttp2_stream* s =
       grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   grpc_error* err = GRPC_ERROR_NONE;
@@ -437,7 +447,8 @@ static grpc_error* GPR_ATTRIBUTE_NOINLINE handle_metadata_size_limit_exceeded(
     size_t new_size, size_t metadata_size_limit) {
   gpr_log(GPR_DEBUG,
           "received initial metadata size exceeds limit (%" PRIuPTR
-          " vs. %" PRIuPTR ")",
+          " vs. %" PRIuPTR
+          "). GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
           new_size, metadata_size_limit);
   grpc_chttp2_cancel_stream(
       t, s,
@@ -518,7 +529,10 @@ static grpc_error* on_trailing_header(void* tp, grpc_mdelem md) {
   if (new_size > metadata_size_limit) {
     gpr_log(GPR_DEBUG,
             "received trailing metadata size exceeds limit (%" PRIuPTR
-            " vs. %" PRIuPTR ")",
+            " vs. %" PRIuPTR
+            "). Please note that the status is also included in the trailing "
+            "metadata and a large status message can also trigger this. "
+            "GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
             new_size, metadata_size_limit);
     grpc_chttp2_cancel_stream(
         t, s,