grpc 1.66.0 → 1.67.0.pre1

data/src/core/server/server_config_selector_filter.cc

@@ -24,7 +24,6 @@
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/server/xds_server_config_fetcher.cc

@@ -586,11 +586,9 @@ XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
 void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     std::shared_ptr<const XdsListenerResource> listener,
     RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_server_config_fetcher)) {
-    LOG(INFO) << "[ListenerWatcher " << this
-              << "] Received LDS update from xds client " << xds_client_.get()
-              << ": " << listener->ToString();
-  }
+  GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
+      << "[ListenerWatcher " << this << "] Received LDS update from xds client "
+      << xds_client_.get() << ": " << listener->ToString();
   auto* tcp_listener =
       absl::get_if<XdsListenerResource::TcpListener>(&listener->listener);
   if (tcp_listener == nullptr) {
@@ -1178,7 +1176,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       config_selector_route.unsupported_action =
           absl::get_if<XdsRouteConfigResource::Route::NonForwardingAction>(
               &route.action) == nullptr;
-      auto result = XdsRouting::GeneratePerHTTPFilterConfigs(
+      auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
           http_filter_registry, http_filters, vhost, route, nullptr,
           ChannelArgs());
       if (!result.ok()) return result.status();

data/src/core/service_config/service_config_call_data.h

@@ -35,9 +35,8 @@
 namespace grpc_core {
 
 /// Stores the service config data associated with an individual call.
-/// A pointer to this object is stored in the call_context
-/// GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA element, so that filters can
-/// easily access method and global parameters for the call.
+/// A pointer to this object is stored in the call context, so that
+/// filters can easily access method and global parameters for the call.
 ///
 /// Must be accessed when holding the call combiner (legacy filter) or from
 /// inside the activity (promise-based filter).

data/src/core/service_config/service_config_channel_arg_filter.cc

@@ -28,7 +28,6 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"

data/src/core/service_config/service_config_impl.h

@@ -29,7 +29,6 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/telemetry/call_tracer.cc

@@ -24,7 +24,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/promise/context.h"

data/src/core/telemetry/metrics.h

@@ -25,7 +25,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/metrics.h>
 #include <grpc/support/port_platform.h>
 

data/src/core/telemetry/stats_data.cc

@@ -106,6 +106,20 @@ Histogram_10000_20 operator-(const Histogram_10000_20& left,
   }
   return result;
 }
+void HistogramCollector_1800000_40::Collect(
+    Histogram_1800000_40* result) const {
+  for (int i = 0; i < 40; i++) {
+    result->buckets_[i] += buckets_[i].load(std::memory_order_relaxed);
+  }
+}
+Histogram_1800000_40 operator-(const Histogram_1800000_40& left,
+                               const Histogram_1800000_40& right) {
+  Histogram_1800000_40 result;
+  for (int i = 0; i < 40; i++) {
+    result.buckets_[i] = left.buckets_[i] - right.buckets_[i];
+  }
+  return result;
+}
 const absl::string_view
     GlobalStats::counter_name[static_cast<int>(Counter::COUNT)] = {
         "client_calls_created",
@@ -123,6 +137,8 @@ const absl::string_view
         "http2_writes_begun",
         "http2_transport_stalls",
         "http2_stream_stalls",
+        "http2_hpack_hits",
+        "http2_hpack_misses",
         "cq_pluck_creates",
         "cq_next_creates",
         "cq_callback_creates",
@@ -161,6 +177,8 @@ const absl::string_view GlobalStats::counter_doc[static_cast<int>(
     "control window",
     "Number of times sending was completely stalled by the stream flow control "
     "window",
+    "Number of HPACK cache hits",
+    "Number of HPACK cache misses (entries added but never used)",
     "Number of completion queues created for cq_pluck (indicates sync api "
     "usage)",
     "Number of completion queues created for cq_next (indicates cq async api "
@@ -192,6 +210,7 @@ const absl::string_view
         "tcp_read_offer_iov_size",
         "http2_send_message_size",
         "http2_metadata_size",
+        "http2_hpack_entry_lifetime",
         "wrr_subchannel_list_size",
         "wrr_subchannel_ready_size",
         "work_serializer_run_time_ms",
@@ -223,6 +242,7 @@ const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     "Number of byte segments offered to each syscall_read",
     "Size of messages received by HTTP2 transport",
     "Number of bytes consumed by metadata, according to HPACK accounting rules",
+    "Lifetime of HPACK entries in the cache (in milliseconds)",
     "Number of subchannels in a subchannel list at picker creation time",
     "Number of READY subchannels in a subchannel list at picker creation time",
     "Number of milliseconds work serializers run for",
@@ -278,6 +298,15 @@ const int kStatsTable10[21] = {0,   1,    2,    4,    7,    12,   19,
 const uint8_t kStatsTable11[23] = {3,  3,  4,  5,  5,  6,  7,  8,
                                    9,  9,  10, 11, 12, 12, 13, 14,
                                    15, 15, 16, 17, 18, 18, 19};
+const int kStatsTable12[41] = {
+    0,      1,      2,      3,       5,      8,      12,     18,     26,
+    37,     53,     76,     108,     153,    217,    308,    436,    617,
+    873,    1235,   1748,   2473,    3499,   4950,   7003,   9907,   14015,
+    19825,  28044,  39670,  56116,   79379,  112286, 158835, 224680, 317821,
+    449574, 635945, 899575, 1272492, 1800000};
+const uint8_t kStatsTable13[37] = {
+    4,  5,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+    22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39};
 }  // namespace
 int Histogram_100000_20::BucketFor(int value) {
   if (value < 3) {
@@ -405,6 +434,29 @@ int Histogram_10000_20::BucketFor(int value) {
     }
   }
 }
+int Histogram_1800000_40::BucketFor(int value) {
+  if (value < 4) {
+    if (value < 0) {
+      return 0;
+    } else {
+      return value;
+    }
+  } else {
+    if (value < 1048577) {
+      DblUint val;
+      val.dbl = value;
+      const int bucket =
+          kStatsTable13[((val.uint - 4616189618054758400ull) >> 51)];
+      return bucket - (value < kStatsTable12[bucket]);
+    } else {
+      if (value < 1272492) {
+        return 38;
+      } else {
+        return 39;
+      }
+    }
+  }
+}
 GlobalStats::GlobalStats()
     : client_calls_created{0},
       server_calls_created{0},
@@ -421,6 +473,8 @@ GlobalStats::GlobalStats()
       http2_writes_begun{0},
       http2_transport_stalls{0},
       http2_stream_stalls{0},
+      http2_hpack_hits{0},
+      http2_hpack_misses{0},
       cq_pluck_creates{0},
       cq_next_creates{0},
       cq_callback_creates{0},
@@ -466,6 +520,9 @@ HistogramView GlobalStats::histogram(Histogram which) const {
     case Histogram::kHttp2MetadataSize:
       return HistogramView{&Histogram_65536_26::BucketFor, kStatsTable2, 26,
                            http2_metadata_size.buckets()};
+    case Histogram::kHttp2HpackEntryLifetime:
+      return HistogramView{&Histogram_1800000_40::BucketFor, kStatsTable12, 40,
+                           http2_hpack_entry_lifetime.buckets()};
     case Histogram::kWrrSubchannelListSize:
       return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            wrr_subchannel_list_size.buckets()};
@@ -560,6 +617,10 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
         data.http2_transport_stalls.load(std::memory_order_relaxed);
     result->http2_stream_stalls +=
         data.http2_stream_stalls.load(std::memory_order_relaxed);
+    result->http2_hpack_hits +=
+        data.http2_hpack_hits.load(std::memory_order_relaxed);
+    result->http2_hpack_misses +=
+        data.http2_hpack_misses.load(std::memory_order_relaxed);
     result->cq_pluck_creates +=
         data.cq_pluck_creates.load(std::memory_order_relaxed);
     result->cq_next_creates +=
@@ -598,6 +659,8 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
     data.tcp_read_offer_iov_size.Collect(&result->tcp_read_offer_iov_size);
     data.http2_send_message_size.Collect(&result->http2_send_message_size);
     data.http2_metadata_size.Collect(&result->http2_metadata_size);
+    data.http2_hpack_entry_lifetime.Collect(
+        &result->http2_hpack_entry_lifetime);
     data.wrr_subchannel_list_size.Collect(&result->wrr_subchannel_list_size);
     data.wrr_subchannel_ready_size.Collect(&result->wrr_subchannel_ready_size);
     data.work_serializer_run_time_ms.Collect(
@@ -664,6 +727,8 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   result->http2_transport_stalls =
       http2_transport_stalls - other.http2_transport_stalls;
   result->http2_stream_stalls = http2_stream_stalls - other.http2_stream_stalls;
+  result->http2_hpack_hits = http2_hpack_hits - other.http2_hpack_hits;
+  result->http2_hpack_misses = http2_hpack_misses - other.http2_hpack_misses;
   result->cq_pluck_creates = cq_pluck_creates - other.cq_pluck_creates;
   result->cq_next_creates = cq_next_creates - other.cq_next_creates;
   result->cq_callback_creates = cq_callback_creates - other.cq_callback_creates;
@@ -695,6 +760,8 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   result->http2_send_message_size =
       http2_send_message_size - other.http2_send_message_size;
   result->http2_metadata_size = http2_metadata_size - other.http2_metadata_size;
+  result->http2_hpack_entry_lifetime =
+      http2_hpack_entry_lifetime - other.http2_hpack_entry_lifetime;
   result->wrr_subchannel_list_size =
       wrr_subchannel_list_size - other.wrr_subchannel_list_size;
   result->wrr_subchannel_ready_size =

data/src/core/telemetry/stats_data.h

@@ -35,6 +35,7 @@ class Histogram_100000_20 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 20; }
   friend Histogram_100000_20 operator-(const Histogram_100000_20& left,
                                        const Histogram_100000_20& right);
 
@@ -58,6 +59,7 @@ class Histogram_65536_26 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 26; }
   friend Histogram_65536_26 operator-(const Histogram_65536_26& left,
                                       const Histogram_65536_26& right);
 
@@ -81,6 +83,7 @@ class Histogram_100_20 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 20; }
   friend Histogram_100_20 operator-(const Histogram_100_20& left,
                                     const Histogram_100_20& right);
 
@@ -104,6 +107,7 @@ class Histogram_16777216_20 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 20; }
   friend Histogram_16777216_20 operator-(const Histogram_16777216_20& left,
                                          const Histogram_16777216_20& right);
 
@@ -127,6 +131,7 @@ class Histogram_80_10 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 10; }
   friend Histogram_80_10 operator-(const Histogram_80_10& left,
                                    const Histogram_80_10& right);
 
@@ -150,6 +155,7 @@ class Histogram_10000_20 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 20; }
   friend Histogram_10000_20 operator-(const Histogram_10000_20& left,
                                       const Histogram_10000_20& right);
 
@@ -168,6 +174,30 @@ class HistogramCollector_10000_20 {
  private:
   std::atomic<uint64_t> buckets_[20]{};
 };
+class HistogramCollector_1800000_40;
+class Histogram_1800000_40 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 40; }
+  friend Histogram_1800000_40 operator-(const Histogram_1800000_40& left,
+                                        const Histogram_1800000_40& right);
+
+ private:
+  friend class HistogramCollector_1800000_40;
+  uint64_t buckets_[40]{};
+};
+class HistogramCollector_1800000_40 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_1800000_40::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_1800000_40* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[40]{};
+};
 struct GlobalStats {
   enum class Counter {
     kClientCallsCreated,
@@ -185,6 +215,8 @@ struct GlobalStats {
     kHttp2WritesBegun,
     kHttp2TransportStalls,
     kHttp2StreamStalls,
+    kHttp2HpackHits,
+    kHttp2HpackMisses,
     kCqPluckCreates,
     kCqNextCreates,
     kCqCallbackCreates,
@@ -213,6 +245,7 @@ struct GlobalStats {
     kTcpReadOfferIovSize,
     kHttp2SendMessageSize,
     kHttp2MetadataSize,
+    kHttp2HpackEntryLifetime,
     kWrrSubchannelListSize,
     kWrrSubchannelReadySize,
     kWorkSerializerRunTimeMs,
@@ -259,6 +292,8 @@ struct GlobalStats {
       uint64_t http2_writes_begun;
       uint64_t http2_transport_stalls;
       uint64_t http2_stream_stalls;
+      uint64_t http2_hpack_hits;
+      uint64_t http2_hpack_misses;
       uint64_t cq_pluck_creates;
       uint64_t cq_next_creates;
       uint64_t cq_callback_creates;
@@ -287,6 +322,7 @@ struct GlobalStats {
   Histogram_80_10 tcp_read_offer_iov_size;
   Histogram_16777216_20 http2_send_message_size;
   Histogram_65536_26 http2_metadata_size;
+  Histogram_1800000_40 http2_hpack_entry_lifetime;
   Histogram_10000_20 wrr_subchannel_list_size;
   Histogram_10000_20 wrr_subchannel_ready_size;
   Histogram_100000_20 work_serializer_run_time_ms;
@@ -367,6 +403,12 @@ class GlobalStatsCollector {
     data_.this_cpu().http2_stream_stalls.fetch_add(1,
                                                    std::memory_order_relaxed);
   }
+  void IncrementHttp2HpackHits() {
+    data_.this_cpu().http2_hpack_hits.fetch_add(1, std::memory_order_relaxed);
+  }
+  void IncrementHttp2HpackMisses() {
+    data_.this_cpu().http2_hpack_misses.fetch_add(1, std::memory_order_relaxed);
+  }
   void IncrementCqPluckCreates() {
     data_.this_cpu().cq_pluck_creates.fetch_add(1, std::memory_order_relaxed);
   }
@@ -447,6 +489,9 @@ class GlobalStatsCollector {
   void IncrementHttp2MetadataSize(int value) {
     data_.this_cpu().http2_metadata_size.Increment(value);
   }
+  void IncrementHttp2HpackEntryLifetime(int value) {
+    data_.this_cpu().http2_hpack_entry_lifetime.Increment(value);
+  }
   void IncrementWrrSubchannelListSize(int value) {
     data_.this_cpu().wrr_subchannel_list_size.Increment(value);
   }
@@ -526,6 +571,8 @@ class GlobalStatsCollector {
     std::atomic<uint64_t> http2_writes_begun{0};
     std::atomic<uint64_t> http2_transport_stalls{0};
     std::atomic<uint64_t> http2_stream_stalls{0};
+    std::atomic<uint64_t> http2_hpack_hits{0};
+    std::atomic<uint64_t> http2_hpack_misses{0};
     std::atomic<uint64_t> cq_pluck_creates{0};
     std::atomic<uint64_t> cq_next_creates{0};
     std::atomic<uint64_t> cq_callback_creates{0};
@@ -551,6 +598,7 @@ class GlobalStatsCollector {
     HistogramCollector_80_10 tcp_read_offer_iov_size;
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
+    HistogramCollector_1800000_40 http2_hpack_entry_lifetime;
     HistogramCollector_10000_20 wrr_subchannel_list_size;
     HistogramCollector_10000_20 wrr_subchannel_ready_size;
     HistogramCollector_100000_20 work_serializer_run_time_ms;

data/src/core/tsi/alts/handshaker/alts_shared_resource.cc

@@ -20,7 +20,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/tsi/alts/handshaker/transport_security_common_api.h

@@ -22,7 +22,6 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"

data/src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.cc

@@ -22,7 +22,6 @@
 #include <string.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"

data/src/core/tsi/fake_transport_security.cc

@@ -28,6 +28,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/dump_args.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/transport_security_grpc.h"
@@ -210,6 +211,8 @@ static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
     frame->offset += to_read_size;
     available_size -= to_read_size;
     frame->size = load32_little_endian(frame->data);
+    if (frame->size < 4) return TSI_DATA_CORRUPTED;
+    if (frame->size > 16 * 1024 * 1024) return TSI_DATA_CORRUPTED;
     tsi_fake_frame_ensure_size(frame);
   }
 
@@ -639,11 +642,9 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
     if (next_message_to_send > TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
       next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(tsi)) {
-      LOG(INFO) << (impl->is_client ? "Client" : "Server") << " prepared "
-                << tsi_fake_handshake_message_to_string(
-                       impl->next_message_to_send);
-    }
+    GRPC_TRACE_LOG(tsi, INFO)
+        << (impl->is_client ? "Client" : "Server") << " prepared "
+        << tsi_fake_handshake_message_to_string(impl->next_message_to_send);
     impl->next_message_to_send = next_message_to_send;
   }
   result =

data/src/core/tsi/ssl/session_cache/ssl_session_cache.cc

@@ -21,7 +21,6 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/util/alloc.cc

@@ -24,7 +24,6 @@
 #include "absl/log/check.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
 

data/src/core/util/gcp_metadata_query.cc

@@ -35,7 +35,6 @@
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

data/src/core/util/http_client/httpcli.cc

@@ -33,7 +33,6 @@
 #include <grpc/grpc.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
@@ -71,15 +70,14 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<void()>> test_only_generate_response;
+  absl::optional<std::function<bool()>> test_only_generate_response;
   if (g_get_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
       // Note that capturing request here assumes it will remain alive
       // until after Start is called. This avoids making a copy as this
       // code path is only used for test mocks.
-      g_get_override(request, uri.authority().c_str(), uri.path().c_str(),
-                     deadline, on_done, response);
+      return g_get_override(request, uri, deadline, on_done, response);
     };
   }
   std::string name =
@@ -97,13 +95,13 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<void()>> test_only_generate_response;
+  absl::optional<std::function<bool()>> test_only_generate_response;
   if (g_post_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
-      g_post_override(request, uri.authority().c_str(), uri.path().c_str(),
-                      request->body, request->body_length, deadline, on_done,
-                      response);
+      return g_post_override(
+          request, uri, absl::string_view(request->body, request->body_length),
+          deadline, on_done, response);
     };
   }
   std::string name =
@@ -121,13 +119,13 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<void()>> test_only_generate_response;
+  absl::optional<std::function<bool()>> test_only_generate_response;
   if (g_put_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
-      g_put_override(request, uri.authority().c_str(), uri.path().c_str(),
-                     request->body, request->body_length, deadline, on_done,
-                     response);
+      return g_put_override(
+          request, uri, absl::string_view(request->body, request->body_length),
+          deadline, on_done, response);
     };
   }
   std::string name =
@@ -157,7 +155,7 @@ HttpRequest::HttpRequest(
     URI uri, const grpc_slice& request_text, grpc_http_response* response,
     Timestamp deadline, const grpc_channel_args* channel_args,
     grpc_closure* on_done, grpc_polling_entity* pollent, const char* name,
-    absl::optional<std::function<void()>> test_only_generate_response,
+    absl::optional<std::function<bool()>> test_only_generate_response,
     RefCountedPtr<grpc_channel_credentials> channel_creds)
     : uri_(std::move(uri)),
       request_text_(request_text),
@@ -204,8 +202,7 @@ HttpRequest::~HttpRequest() {
 void HttpRequest::Start() {
   MutexLock lock(&mu_);
   if (test_only_generate_response_.has_value()) {
-    test_only_generate_response_.value()();
-    return;
+    if (test_only_generate_response_.value()()) return;
   }
   Ref().release();  // ref held by pending DNS resolution
   dns_request_handle_ = resolver_->LookupHostname(

data/src/core/util/http_client/httpcli.h

@@ -30,6 +30,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
@@ -59,18 +60,22 @@
 
 // override functions return 1 if they handled the request, 0 otherwise
 typedef int (*grpc_httpcli_get_override)(const grpc_http_request* request,
-                                         const char* host, const char* path,
+                                         const grpc_core::URI& uri,
+                                         grpc_core::Timestamp deadline,
+                                         grpc_closure* on_complete,
+                                         grpc_http_response* response);
+typedef int (*grpc_httpcli_post_override)(const grpc_http_request* request,
+                                          const grpc_core::URI& uri,
+                                          absl::string_view body,
+                                          grpc_core::Timestamp deadline,
+                                          grpc_closure* on_complete,
+                                          grpc_http_response* response);
+typedef int (*grpc_httpcli_put_override)(const grpc_http_request* request,
+                                         const grpc_core::URI& uri,
+                                         absl::string_view body,
                                          grpc_core::Timestamp deadline,
                                          grpc_closure* on_complete,
                                          grpc_http_response* response);
-typedef int (*grpc_httpcli_post_override)(
-    const grpc_http_request* request, const char* host, const char* path,
-    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
-    grpc_closure* on_complete, grpc_http_response* response);
-typedef int (*grpc_httpcli_put_override)(
-    const grpc_http_request* request, const char* host, const char* path,
-    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
-    grpc_closure* on_complete, grpc_http_response* response);
 
 namespace grpc_core {
 
@@ -160,7 +165,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
               grpc_http_response* response, Timestamp deadline,
               const grpc_channel_args* channel_args, grpc_closure* on_done,
               grpc_polling_entity* pollent, const char* name,
-              absl::optional<std::function<void()>> test_only_generate_response,
+              absl::optional<std::function<bool()>> test_only_generate_response,
               RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   ~HttpRequest() override;
@@ -245,7 +250,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   ResourceQuotaRefPtr resource_quota_;
   grpc_polling_entity* pollent_;
   grpc_pollset_set* pollset_set_;
-  const absl::optional<std::function<void()>> test_only_generate_response_;
+  const absl::optional<std::function<bool()>> test_only_generate_response_;
   Mutex mu_;
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;

data/src/core/util/http_client/parser.cc

@@ -376,10 +376,9 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
     case GRPC_HTTP_HEADERS:
     case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
-        if (GRPC_TRACE_FLAG_ENABLED(http1)) {
-          LOG(ERROR) << "HTTP header max line length ("
-                     << GRPC_HTTP_PARSER_MAX_HEADER_LENGTH << ") exceeded";
-        }
+        GRPC_TRACE_LOG(http1, ERROR)
+            << "HTTP header max line length ("
+            << GRPC_HTTP_PARSER_MAX_HEADER_LENGTH << ") exceeded";
         return GRPC_ERROR_CREATE("HTTP header max line length exceeded");
       }
       parser->cur_line[parser->cur_line_length] = byte;

data/src/core/util/json/json_reader.cc

@@ -36,7 +36,6 @@
 #include "absl/types/variant.h"
 
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/util/json/json.h"