grpc 1.68.1 → 1.69.0.pre1

data/src/core/telemetry/stats_data.cc

@@ -216,6 +216,16 @@ const absl::string_view
         "http2_send_message_size",
         "http2_metadata_size",
         "http2_hpack_entry_lifetime",
+        "http2_header_table_size",
+        "http2_initial_window_size",
+        "http2_max_concurrent_streams",
+        "http2_max_frame_size",
+        "http2_max_header_list_size",
+        "http2_preferred_receive_crypto_message_size",
+        "http2_stream_remote_window_update",
+        "http2_transport_remote_window_update",
+        "http2_transport_window_update_period",
+        "http2_stream_window_update_period",
         "wrr_subchannel_list_size",
         "wrr_subchannel_ready_size",
         "work_serializer_run_time_ms",
@@ -248,6 +258,17 @@ const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     "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)",
+    "Http2 header table size received through SETTINGS frame",
+    "Http2 initial window size received through SETTINGS frame",
+    "Http2 max concurrent streams received through SETTINGS frame",
+    "Http2 max frame size received through SETTINGS frame",
+    "Http2 max header list size received through SETTINGS frame",
+    "Http2 preferred receive crypto message size received through SETTINGS "
+    "frame",
+    "Stream window update sent by peer",
+    "Transport window update sent by peer",
+    "Period in milliseconds at which peer sends transport window update",
+    "Period in milliseconds at which peer sends stream window update",
     "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",
@@ -531,6 +552,37 @@ HistogramView GlobalStats::histogram(Histogram which) const {
     case Histogram::kHttp2HpackEntryLifetime:
       return HistogramView{&Histogram_1800000_40::BucketFor, kStatsTable12, 40,
                            http2_hpack_entry_lifetime.buckets()};
+    case Histogram::kHttp2HeaderTableSize:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_header_table_size.buckets()};
+    case Histogram::kHttp2InitialWindowSize:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_initial_window_size.buckets()};
+    case Histogram::kHttp2MaxConcurrentStreams:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_max_concurrent_streams.buckets()};
+    case Histogram::kHttp2MaxFrameSize:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_max_frame_size.buckets()};
+    case Histogram::kHttp2MaxHeaderListSize:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_max_header_list_size.buckets()};
+    case Histogram::kHttp2PreferredReceiveCryptoMessageSize:
+      return HistogramView{
+          &Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+          http2_preferred_receive_crypto_message_size.buckets()};
+    case Histogram::kHttp2StreamRemoteWindowUpdate:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_stream_remote_window_update.buckets()};
+    case Histogram::kHttp2TransportRemoteWindowUpdate:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           http2_transport_remote_window_update.buckets()};
+    case Histogram::kHttp2TransportWindowUpdatePeriod:
+      return HistogramView{&Histogram_100000_20::BucketFor, kStatsTable0, 20,
+                           http2_transport_window_update_period.buckets()};
+    case Histogram::kHttp2StreamWindowUpdatePeriod:
+      return HistogramView{&Histogram_100000_20::BucketFor, kStatsTable0, 20,
+                           http2_stream_window_update_period.buckets()};
     case Histogram::kWrrSubchannelListSize:
       return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            wrr_subchannel_list_size.buckets()};
@@ -675,6 +727,23 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
     data.http2_metadata_size.Collect(&result->http2_metadata_size);
     data.http2_hpack_entry_lifetime.Collect(
         &result->http2_hpack_entry_lifetime);
+    data.http2_header_table_size.Collect(&result->http2_header_table_size);
+    data.http2_initial_window_size.Collect(&result->http2_initial_window_size);
+    data.http2_max_concurrent_streams.Collect(
+        &result->http2_max_concurrent_streams);
+    data.http2_max_frame_size.Collect(&result->http2_max_frame_size);
+    data.http2_max_header_list_size.Collect(
+        &result->http2_max_header_list_size);
+    data.http2_preferred_receive_crypto_message_size.Collect(
+        &result->http2_preferred_receive_crypto_message_size);
+    data.http2_stream_remote_window_update.Collect(
+        &result->http2_stream_remote_window_update);
+    data.http2_transport_remote_window_update.Collect(
+        &result->http2_transport_remote_window_update);
+    data.http2_transport_window_update_period.Collect(
+        &result->http2_transport_window_update_period);
+    data.http2_stream_window_update_period.Collect(
+        &result->http2_stream_window_update_period);
     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(
@@ -780,6 +849,31 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   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->http2_header_table_size =
+      http2_header_table_size - other.http2_header_table_size;
+  result->http2_initial_window_size =
+      http2_initial_window_size - other.http2_initial_window_size;
+  result->http2_max_concurrent_streams =
+      http2_max_concurrent_streams - other.http2_max_concurrent_streams;
+  result->http2_max_frame_size =
+      http2_max_frame_size - other.http2_max_frame_size;
+  result->http2_max_header_list_size =
+      http2_max_header_list_size - other.http2_max_header_list_size;
+  result->http2_preferred_receive_crypto_message_size =
+      http2_preferred_receive_crypto_message_size -
+      other.http2_preferred_receive_crypto_message_size;
+  result->http2_stream_remote_window_update =
+      http2_stream_remote_window_update -
+      other.http2_stream_remote_window_update;
+  result->http2_transport_remote_window_update =
+      http2_transport_remote_window_update -
+      other.http2_transport_remote_window_update;
+  result->http2_transport_window_update_period =
+      http2_transport_window_update_period -
+      other.http2_transport_window_update_period;
+  result->http2_stream_window_update_period =
+      http2_stream_window_update_period -
+      other.http2_stream_window_update_period;
   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

@@ -247,6 +247,16 @@ struct GlobalStats {
     kHttp2SendMessageSize,
     kHttp2MetadataSize,
     kHttp2HpackEntryLifetime,
+    kHttp2HeaderTableSize,
+    kHttp2InitialWindowSize,
+    kHttp2MaxConcurrentStreams,
+    kHttp2MaxFrameSize,
+    kHttp2MaxHeaderListSize,
+    kHttp2PreferredReceiveCryptoMessageSize,
+    kHttp2StreamRemoteWindowUpdate,
+    kHttp2TransportRemoteWindowUpdate,
+    kHttp2TransportWindowUpdatePeriod,
+    kHttp2StreamWindowUpdatePeriod,
     kWrrSubchannelListSize,
     kWrrSubchannelReadySize,
     kWorkSerializerRunTimeMs,
@@ -327,6 +337,16 @@ struct GlobalStats {
   Histogram_16777216_20 http2_send_message_size;
   Histogram_65536_26 http2_metadata_size;
   Histogram_1800000_40 http2_hpack_entry_lifetime;
+  Histogram_16777216_20 http2_header_table_size;
+  Histogram_16777216_20 http2_initial_window_size;
+  Histogram_16777216_20 http2_max_concurrent_streams;
+  Histogram_16777216_20 http2_max_frame_size;
+  Histogram_16777216_20 http2_max_header_list_size;
+  Histogram_16777216_20 http2_preferred_receive_crypto_message_size;
+  Histogram_16777216_20 http2_stream_remote_window_update;
+  Histogram_16777216_20 http2_transport_remote_window_update;
+  Histogram_100000_20 http2_transport_window_update_period;
+  Histogram_100000_20 http2_stream_window_update_period;
   Histogram_10000_20 wrr_subchannel_list_size;
   Histogram_10000_20 wrr_subchannel_ready_size;
   Histogram_100000_20 work_serializer_run_time_ms;
@@ -506,6 +526,37 @@ class GlobalStatsCollector {
   void IncrementHttp2HpackEntryLifetime(int value) {
     data_.this_cpu().http2_hpack_entry_lifetime.Increment(value);
   }
+  void IncrementHttp2HeaderTableSize(int value) {
+    data_.this_cpu().http2_header_table_size.Increment(value);
+  }
+  void IncrementHttp2InitialWindowSize(int value) {
+    data_.this_cpu().http2_initial_window_size.Increment(value);
+  }
+  void IncrementHttp2MaxConcurrentStreams(int value) {
+    data_.this_cpu().http2_max_concurrent_streams.Increment(value);
+  }
+  void IncrementHttp2MaxFrameSize(int value) {
+    data_.this_cpu().http2_max_frame_size.Increment(value);
+  }
+  void IncrementHttp2MaxHeaderListSize(int value) {
+    data_.this_cpu().http2_max_header_list_size.Increment(value);
+  }
+  void IncrementHttp2PreferredReceiveCryptoMessageSize(int value) {
+    data_.this_cpu().http2_preferred_receive_crypto_message_size.Increment(
+        value);
+  }
+  void IncrementHttp2StreamRemoteWindowUpdate(int value) {
+    data_.this_cpu().http2_stream_remote_window_update.Increment(value);
+  }
+  void IncrementHttp2TransportRemoteWindowUpdate(int value) {
+    data_.this_cpu().http2_transport_remote_window_update.Increment(value);
+  }
+  void IncrementHttp2TransportWindowUpdatePeriod(int value) {
+    data_.this_cpu().http2_transport_window_update_period.Increment(value);
+  }
+  void IncrementHttp2StreamWindowUpdatePeriod(int value) {
+    data_.this_cpu().http2_stream_window_update_period.Increment(value);
+  }
   void IncrementWrrSubchannelListSize(int value) {
     data_.this_cpu().wrr_subchannel_list_size.Increment(value);
   }
@@ -616,6 +667,16 @@ class GlobalStatsCollector {
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
     HistogramCollector_1800000_40 http2_hpack_entry_lifetime;
+    HistogramCollector_16777216_20 http2_header_table_size;
+    HistogramCollector_16777216_20 http2_initial_window_size;
+    HistogramCollector_16777216_20 http2_max_concurrent_streams;
+    HistogramCollector_16777216_20 http2_max_frame_size;
+    HistogramCollector_16777216_20 http2_max_header_list_size;
+    HistogramCollector_16777216_20 http2_preferred_receive_crypto_message_size;
+    HistogramCollector_16777216_20 http2_stream_remote_window_update;
+    HistogramCollector_16777216_20 http2_transport_remote_window_update;
+    HistogramCollector_100000_20 http2_transport_window_update_period;
+    HistogramCollector_100000_20 http2_stream_window_update_period;
     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/frame_protector/alts_counter.h

@@ -88,7 +88,7 @@ size_t alts_counter_get_size(alts_counter* crypter_counter);
 unsigned char* alts_counter_get_counter(alts_counter* crypter_counter);
 
 ///
-/// This method de-allocates all memory allocated to an alts_coutner instance.
+/// This method de-allocates all memory allocated to an alts_counter instance.
 ///- crypter_counter: an alts_counter instance.
 ///
 void alts_counter_destroy(alts_counter* crypter_counter);

data/src/core/tsi/alts/frame_protector/alts_seal_privacy_integrity_crypter.cc

@@ -30,7 +30,7 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-// Perform input santity check for a seal operation.
+// Perform input sanity check for a seal operation.
 static grpc_status_code seal_check(alts_crypter* c, const unsigned char* data,
                                    size_t data_allocated_size, size_t data_size,
                                    size_t* output_size, char** error_details) {

data/src/core/tsi/alts/frame_protector/alts_unseal_privacy_integrity_crypter.cc

@@ -30,7 +30,7 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-// Perform input santity check.
+// Perform input sanity check.
 static grpc_status_code unseal_check(alts_crypter* c, const unsigned char* data,
                                      size_t /*data_allocated_size*/,
                                      size_t data_size, size_t* output_size,

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

@@ -27,13 +27,13 @@
 #include "src/core/util/crash.h"
 #include "src/proto/grpc/gcp/transport_security_common.upb.h"
 
-// C struct coresponding to protobuf message RpcProtocolVersions.Version
+// C struct corresponding to protobuf message RpcProtocolVersions.Version
 typedef struct _grpc_gcp_RpcProtocolVersions_Version {
   uint32_t major;
   uint32_t minor;
 } grpc_gcp_rpc_protocol_versions_version;
 
-// C struct coresponding to protobuf message RpcProtocolVersions
+// C struct corresponding to protobuf message RpcProtocolVersions
 typedef struct _grpc_gcp_RpcProtocolVersions {
   grpc_gcp_rpc_protocol_versions_version max_rpc_version;
   grpc_gcp_rpc_protocol_versions_version min_rpc_version;

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

@@ -156,7 +156,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
   }
   alts_zero_copy_grpc_protector* protector =
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
-  // Calls alts_grpc_record_protocol protect repeatly.
+  // Calls alts_grpc_record_protocol protect repeatedly.
   while (unprotected_slices->length > protector->max_unprotected_data_size) {
     grpc_slice_buffer_move_first(unprotected_slices,
                                  protector->max_unprotected_data_size,

data/src/core/tsi/ssl_transport_security.cc

@@ -1656,11 +1656,18 @@ static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl,
       default: {
         char err_str[256];
         ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
-        LOG(ERROR) << "Handshake failed with fatal error "
-                   << grpc_core::SslErrorString(ssl_result) << ": " << err_str;
+        long verify_result = SSL_get_verify_result(impl->ssl);
+        std::string verify_result_str;
+        if (verify_result != X509_V_OK) {
+          const char* verify_err = X509_verify_cert_error_string(verify_result);
+          verify_result_str = absl::StrCat(": ", verify_err);
+        }
+        LOG(INFO) << "Handshake failed with error "
+                  << grpc_core::SslErrorString(ssl_result) << ": " << err_str
+                  << verify_result_str;
         if (error != nullptr) {
           *error = absl::StrCat(grpc_core::SslErrorString(ssl_result), ": ",
-                                err_str);
+                                err_str, verify_result_str);
         }
         impl->result = TSI_PROTOCOL_FAILURE;
         return impl->result;
@@ -1710,7 +1717,7 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
-  // Atempt to read all of the bytes in SSL's read BIO. These bytes should
+  // Attempt to read all of the bytes in SSL's read BIO. These bytes should
   // contain application data records that were appended to a handshake record
   // containing the ClientFinished or ServerFinished message.
   size_t bytes_in_ssl = BIO_pending(SSL_get_rbio(impl->ssl));

data/src/core/tsi/ssl_transport_security.h

@@ -95,7 +95,7 @@ static constexpr bool tsi_tls_session_key_logging_supported() {
 // --- tsi_ssl_client_handshaker_factory object ---
 
 // This object creates a client tsi_handshaker objects implemented in terms of
-// the TLS 1.2 specificiation.
+// the TLS 1.2 specification.
 
 typedef struct tsi_ssl_client_handshaker_factory
     tsi_ssl_client_handshaker_factory;
@@ -243,7 +243,7 @@ void tsi_ssl_client_handshaker_factory_unref(
 // --- tsi_ssl_server_handshaker_factory object ---
 
 // This object creates a client tsi_handshaker objects implemented in terms of
-// the TLS 1.2 specificiation.
+// the TLS 1.2 specification.
 
 typedef struct tsi_ssl_server_handshaker_factory
     tsi_ssl_server_handshaker_factory;

data/src/core/tsi/ssl_transport_security_utils.h

@@ -97,7 +97,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
                                size_t* protected_output_frames_size);
 
 // Builds a TLS frame out of the remaining plaintext bytes that's left in
-// buffer. Populates the size of the remianing TLS frame to
+// buffer. Populates the size of the remaining TLS frame to
 // |still_pending_size|.
 //
 // buffer_size: the size of |buffer|. If |buffer_offset| equals |buffer_size|,

data/src/core/tsi/transport_security_interface.h

@@ -409,7 +409,7 @@ tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
 
 // TO BE DEPRECATED SOON.
 // Gets the result of the handshaker.
-// Returns TSI_OK if the hanshake completed successfully and there has been no
+// Returns TSI_OK if the handshake completed successfully and there has been no
 // errors. Returns TSI_HANDSHAKE_IN_PROGRESS if the handshaker is not done yet
 // but no error has been encountered so far. Otherwise the handshaker failed
 // with the returned error.
@@ -433,7 +433,7 @@ tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer);
 // is done. After this method has been called successfully, the only method
 // that can be called on this object is Destroy.
 // - max_output_protected_frame_size is an input/output parameter specifying the
-//   desired max output protected frame size as input and outputing the actual
+//   desired max output protected frame size as input and outputting the actual
 //   max output frame size as the output. Passing NULL is OK and will result in
 //   the implementation choosing the default maximum protected frame size. Note
 //   that this size only applies to outgoing frames (generated with

data/src/core/util/fork.cc

@@ -25,7 +25,7 @@
 
 #include <utility>
 
-#include "src/core/lib/config/config_vars.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/util/no_destruct.h"
 

data/src/core/util/fork.h

@@ -37,7 +37,7 @@ class GPR_DLL Fork {
 
   static void GlobalInit();
 
-  // Returns true if fork suppport is enabled, false otherwise
+  // Returns true if fork support is enabled, false otherwise
   static bool Enabled();
 
   // Increment the count of active ExecCtxs.
@@ -66,7 +66,7 @@ class GPR_DLL Fork {
   // Check if there is a single active ExecCtx
   // (the one used to invoke this function).  If there are more,
   // return false.  Otherwise, return true and block creation of
-  // more ExecCtx s until AlloWExecCtx() is called
+  // more ExecCtx s until AllowExecCtx() is called
   //
   static bool BlockExecCtx();
   static void AllowExecCtx();

data/src/core/util/gpr_time.cc

@@ -224,7 +224,7 @@ int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold) {
 int32_t gpr_time_to_millis(gpr_timespec t) {
   if (t.tv_sec >= 2147483) {
     if (t.tv_sec == 2147483 && t.tv_nsec < 648 * GPR_NS_PER_MS) {
-      return 2147483 * GPR_MS_PER_SEC + t.tv_nsec / GPR_NS_PER_MS;
+      return (2147483 * GPR_MS_PER_SEC) + (t.tv_nsec / GPR_NS_PER_MS);
     }
     return 2147483647;
   } else if (t.tv_sec <= -2147483) {
@@ -232,13 +232,13 @@ int32_t gpr_time_to_millis(gpr_timespec t) {
     // care?)
     return -2147483647;
   } else {
-    return static_cast<int32_t>(t.tv_sec * GPR_MS_PER_SEC +
-                                t.tv_nsec / GPR_NS_PER_MS);
+    return static_cast<int32_t>((t.tv_sec * GPR_MS_PER_SEC) +
+                                (t.tv_nsec / GPR_NS_PER_MS));
   }
 }
 
 double gpr_timespec_to_micros(gpr_timespec t) {
-  return static_cast<double>(t.tv_sec) * GPR_US_PER_SEC + t.tv_nsec * 1e-3;
+  return (static_cast<double>(t.tv_sec) * GPR_US_PER_SEC) + (t.tv_nsec * 1e-3);
 }
 
 gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {

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

@@ -31,13 +31,13 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -79,8 +79,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
   }
   std::string name =
       absl::StrFormat("HTTP:GET:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_get_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_get_request(request, uri.authority().c_str(),
+                                      uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -103,8 +104,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
   }
   std::string name =
       absl::StrFormat("HTTP:POST:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_post_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_post_request(request, uri.authority().c_str(),
+                                       uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -127,8 +129,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
   }
   std::string name =
       absl::StrFormat("HTTP:PUT:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_put_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_put_request(request, uri.authority().c_str(),
+                                      uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -241,6 +244,8 @@ void HttpRequest::AppendError(grpc_error_handle error) {
 
 void HttpRequest::OnReadInternal(grpc_error_handle error) {
   for (size_t i = 0; i < incoming_.count; i++) {
+    GRPC_TRACE_LOG(http1, INFO)
+        << "HTTP response data: " << StringViewFromSlice(incoming_.slices[i]);
     if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
       have_read_byte_ = 1;
       grpc_error_handle err =
@@ -275,6 +280,8 @@ void HttpRequest::ContinueDoneWriteAfterScheduleOnExecCtx(
 }
 
 void HttpRequest::StartWrite() {
+  GRPC_TRACE_LOG(http1, INFO)
+      << "Sending HTTP1 request: " << StringViewFromSlice(request_text_);
   CSliceRef(request_text_);
   grpc_slice_buffer_add(&outgoing_, request_text_);
   Ref().release();  // ref held by pending write

data/src/core/util/json/json_object_loader.h

@@ -457,7 +457,7 @@ const LoaderInterface* LoaderForType() {
 struct Element {
   Element() = default;
   template <typename A, typename B>
-  Element(const char* name, bool optional, B A::*p,
+  Element(const char* name, bool optional, B A::* p,
           const LoaderInterface* loader, const char* enable_key)
       : loader(loader),
         member_offset(static_cast<uint16_t>(
@@ -564,13 +564,13 @@ class JsonObjectLoader final {
 
   template <typename U>
   JsonObjectLoader<T, kElemCount + 1> Field(
-      const char* name, U T::*p, const char* enable_key = nullptr) const {
+      const char* name, U T::* p, const char* enable_key = nullptr) const {
     return Field(name, false, p, enable_key);
   }
 
   template <typename U>
   JsonObjectLoader<T, kElemCount + 1> OptionalField(
-      const char* name, U T::*p, const char* enable_key = nullptr) const {
+      const char* name, U T::* p, const char* enable_key = nullptr) const {
     return Field(name, true, p, enable_key);
   }
 
@@ -581,7 +581,7 @@ class JsonObjectLoader final {
  private:
   template <typename U>
   JsonObjectLoader<T, kElemCount + 1> Field(const char* name, bool optional,
-                                            U T::*p,
+                                            U T::* p,
                                             const char* enable_key) const {
     return JsonObjectLoader<T, kElemCount + 1>(
         elements_, Element(name, optional, p, LoaderForType<U>(), enable_key));

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

@@ -35,7 +35,7 @@ namespace {
 // The idea of the writer is basically symmetrical of the reader. While the
 // reader emits various calls to your code, the writer takes basically the
 // same calls and emit json out of it. It doesn't try to make any check on
-// the order of the calls you do on it. Meaning you can theorically force
+// the order of the calls you do on it. Meaning you can theoretically force
 // it to generate invalid json.
 //
 // Also, unlike the reader, the writer expects UTF-8 encoded input strings.