grpc 1.65.2 → 1.66.0.pre3

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

@@ -226,7 +226,8 @@ typedef enum {
 struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                                      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
-                        grpc_endpoint* ep, bool is_client);
+                        grpc_core::OrphanablePtr<grpc_endpoint> endpoint,
+                        bool is_client);
   ~grpc_chttp2_transport() override;
 
   void Orphan() override;
@@ -257,7 +258,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                      grpc_pollset_set* pollset_set) override;
   void PerformOp(grpc_transport_op* op) override;
 
-  grpc_endpoint* ep;
+  grpc_core::OrphanablePtr<grpc_endpoint> ep;
   grpc_core::Mutex ep_destroy_mu;  // Guards endpoint destruction only.
 
   grpc_core::Slice peer_string;
@@ -553,6 +554,51 @@ typedef enum {
   GRPC_METADATA_PUBLISHED_AT_CLOSE
 } grpc_published_metadata_method;
 
+namespace grpc_core {
+
+// A CallTracer wrapper that updates both the legacy and new APIs for
+// transport byte sizes.
+// TODO(ctiller): This can go away as part of removing the
+// grpc_transport_stream_stats struct.
+class Chttp2CallTracerWrapper final : public CallTracerInterface {
+ public:
+  explicit Chttp2CallTracerWrapper(grpc_chttp2_stream* stream)
+      : stream_(stream) {}
+
+  void RecordIncomingBytes(
+      const TransportByteSize& transport_byte_size) override;
+  void RecordOutgoingBytes(
+      const TransportByteSize& transport_byte_size) override;
+
+  // Everything else is a no-op.
+  void RecordSendInitialMetadata(
+      grpc_metadata_batch* /*send_initial_metadata*/) override {}
+  void RecordSendTrailingMetadata(
+      grpc_metadata_batch* /*send_trailing_metadata*/) override {}
+  void RecordSendMessage(const SliceBuffer& /*send_message*/) override {}
+  void RecordSendCompressedMessage(
+      const SliceBuffer& /*send_compressed_message*/) override {}
+  void RecordReceivedInitialMetadata(
+      grpc_metadata_batch* /*recv_initial_metadata*/) override {}
+  void RecordReceivedMessage(const SliceBuffer& /*recv_message*/) override {}
+  void RecordReceivedDecompressedMessage(
+      const SliceBuffer& /*recv_decompressed_message*/) override {}
+  void RecordCancel(grpc_error_handle /*cancel_error*/) override {}
+  std::shared_ptr<TcpTracerInterface> StartNewTcpTrace() override {
+    return nullptr;
+  }
+  void RecordAnnotation(absl::string_view /*annotation*/) override {}
+  void RecordAnnotation(const Annotation& /*annotation*/) override {}
+  std::string TraceId() override { return ""; }
+  std::string SpanId() override { return ""; }
+  bool IsSampled() override { return false; }
+
+ private:
+  grpc_chttp2_stream* stream_;
+};
+
+}  // namespace grpc_core
+
 struct grpc_chttp2_stream {
   grpc_chttp2_stream(grpc_chttp2_transport* t, grpc_stream_refcount* refcount,
                      const void* server_data, grpc_core::Arena* arena);
@@ -652,7 +698,11 @@ struct grpc_chttp2_stream {
   /// Number of times written
   int64_t write_counter = 0;
 
+  grpc_core::Chttp2CallTracerWrapper call_tracer_wrapper;
+
   /// Only set when enabled.
+  // TODO(roth): Remove this when the call_tracer_in_transport
+  // experiment finishes rolling out.
   grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
 
   /// Only set when enabled.
@@ -807,13 +857,8 @@ void grpc_chttp2_settings_timeout(
 #define GRPC_CHTTP2_CLIENT_CONNECT_STRLEN \
   (sizeof(GRPC_CHTTP2_CLIENT_CONNECT_STRING) - 1)
 
-//
-#define GRPC_CHTTP2_IF_TRACING(stmt)     \
-  do {                                   \
-    if (GRPC_TRACE_FLAG_ENABLED(http)) { \
-      (stmt);                            \
-    }                                    \
-  } while (0)
+#define GRPC_CHTTP2_IF_TRACING(severity) \
+  LOG_IF(severity, GRPC_TRACE_FLAG_ENABLED(http))
 
 void grpc_chttp2_fake_status(grpc_chttp2_transport* t,
                              grpc_chttp2_stream* stream,

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

@@ -40,7 +40,6 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channelz.h"
@@ -332,10 +331,11 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        gpr_log(GPR_INFO, "INCOMING[%p]: %s len:%d id:0x%08x", t,
-                FrameTypeString(t->incoming_frame_type, t->incoming_frame_flags)
-                    .c_str(),
-                t->incoming_frame_size, t->incoming_stream_id);
+        LOG(INFO) << "INCOMING[" << t << "]: "
+                  << FrameTypeString(t->incoming_frame_type,
+                                     t->incoming_frame_flags)
+                  << " len:" << t->incoming_frame_size
+                  << absl::StrFormat(" id:0x%08x", t->incoming_stream_id);
       }
       t->deframe_state = GRPC_DTS_FRAME;
       err = init_frame_parser(t, requests_started);
@@ -453,7 +453,8 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
       return init_goaway_parser(t);
     default:
       if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        gpr_log(GPR_ERROR, "Unknown frame type %02x", t->incoming_frame_type);
+        LOG(ERROR) << "Unknown frame type "
+                   << absl::StrFormat("%02x", t->incoming_frame_type);
       }
       return init_non_header_skip_frame_parser(t);
   }
@@ -554,7 +555,7 @@ static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
     return init_non_header_skip_frame_parser(t);
   }
   s->received_bytes += t->incoming_frame_size;
-  s->stats.incoming.framing_bytes += 9;
+  s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   if (s->read_closed) {
     return init_non_header_skip_frame_parser(t);
   }
@@ -573,7 +574,7 @@ error_handler:
                                    absl_status_to_grpc_error(status));
     grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
                                              GRPC_HTTP2_PROTOCOL_ERROR,
-                                             &s->stats.outgoing);
+                                             &s->call_tracer_wrapper);
     return init_non_header_skip_frame_parser(t);
   } else {
     return absl_status_to_grpc_error(status);
@@ -611,9 +612,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   s = grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   if (s == nullptr) {
     if (GPR_UNLIKELY(is_continuation)) {
-      GRPC_CHTTP2_IF_TRACING(
-          gpr_log(GPR_ERROR,
-                  "grpc_chttp2_stream disbanded before CONTINUATION received"));
+      GRPC_CHTTP2_IF_TRACING(ERROR)
+          << "grpc_chttp2_stream disbanded before CONTINUATION received";
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
     if (t->is_client) {
@@ -621,23 +621,21 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                      t->incoming_stream_id < t->next_stream_id)) {
         // this is an old (probably cancelled) grpc_chttp2_stream
       } else {
-        GRPC_CHTTP2_IF_TRACING(gpr_log(
-            GPR_ERROR, "ignoring new grpc_chttp2_stream creation on client"));
+        GRPC_CHTTP2_IF_TRACING(ERROR)
+            << "ignoring new grpc_chttp2_stream creation on client";
       }
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(t->last_new_stream_id >= t->incoming_stream_id)) {
-      GRPC_CHTTP2_IF_TRACING(gpr_log(
-          GPR_ERROR,
-          "ignoring out of order new grpc_chttp2_stream request on server; "
-          "last grpc_chttp2_stream "
-          "id=%d, new grpc_chttp2_stream id=%d",
-          t->last_new_stream_id, t->incoming_stream_id));
+      GRPC_CHTTP2_IF_TRACING(ERROR)
+          << "ignoring out of order new grpc_chttp2_stream request on server; "
+             "last grpc_chttp2_stream id="
+          << t->last_new_stream_id
+          << ", new grpc_chttp2_stream id=" << t->incoming_stream_id;
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY((t->incoming_stream_id & 1) == 0)) {
-      GRPC_CHTTP2_IF_TRACING(gpr_log(
-          GPR_ERROR,
-          "ignoring grpc_chttp2_stream with non-client generated index %d",
-          t->incoming_stream_id));
+      GRPC_CHTTP2_IF_TRACING(ERROR)
+          << "ignoring grpc_chttp2_stream with non-client generated index "
+          << t->incoming_stream_id;
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
                             t->settings.acked().max_concurrent_streams())) {
@@ -678,21 +676,22 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
                t->sent_goaway_state ==
                    GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED) {
-      GRPC_CHTTP2_IF_TRACING(gpr_log(
-          GPR_INFO,
-          "transport:%p SERVER peer:%s Final GOAWAY sent. Ignoring new "
-          "grpc_chttp2_stream request id=%d, last grpc_chttp2_stream id=%d",
-          t, std::string(t->peer_string.as_string_view()).c_str(),
-          t->incoming_stream_id, t->last_new_stream_id));
+      GRPC_CHTTP2_IF_TRACING(INFO)
+          << "transport:" << t
+          << " SERVER peer:" << t->peer_string.as_string_view()
+          << " Final GOAWAY sent. Ignoring new grpc_chttp2_stream request "
+             "id="
+          << t->incoming_stream_id
+          << ", last grpc_chttp2_stream id=" << t->last_new_stream_id;
+      ;
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (t->num_incoming_streams_before_settings_ack == 0) {
-      GRPC_CHTTP2_IF_TRACING(gpr_log(
-          GPR_ERROR,
-          "transport:%p SERVER peer:%s rejecting grpc_chttp2_stream id=%d, "
-          "last grpc_chttp2_stream id=%d before settings have been "
-          "acknowledged",
-          t, std::string(t->peer_string.as_string_view()).c_str(),
-          t->incoming_stream_id, t->last_new_stream_id));
+      GRPC_CHTTP2_IF_TRACING(ERROR)
+          << "transport:" << t
+          << " SERVER peer:" << t->peer_string.as_string_view()
+          << " rejecting grpc_chttp2_stream id=" << t->incoming_stream_id
+          << ", last grpc_chttp2_stream id=" << t->last_new_stream_id
+          << " before settings have been acknowledged";
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
           &t->qbuf,
@@ -708,18 +707,16 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         grpc_chttp2_parsing_accept_stream(t, t->incoming_stream_id);
     ++requests_started;
     if (GPR_UNLIKELY(s == nullptr)) {
-      GRPC_CHTTP2_IF_TRACING(
-          gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
+      GRPC_CHTTP2_IF_TRACING(ERROR) << "grpc_chttp2_stream not accepted";
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
     if (GRPC_TRACE_FLAG_ENABLED(http) ||
         GRPC_TRACE_FLAG_ENABLED(chttp2_new_stream)) {
-      gpr_log(GPR_INFO,
-              "[t:%p fd:%d peer:%s] Accepting new stream; "
-              "num_incoming_streams_before_settings_ack=%u",
-              t, grpc_endpoint_get_fd(t->ep),
-              std::string(t->peer_string.as_string_view()).c_str(),
-              t->num_incoming_streams_before_settings_ack);
+      LOG(INFO) << "[t:" << t << " fd:" << grpc_endpoint_get_fd(t->ep.get())
+                << " peer:" << t->peer_string.as_string_view()
+                << "] Accepting new stream; "
+                   "num_incoming_streams_before_settings_ack="
+                << t->num_incoming_streams_before_settings_ack;
     }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
@@ -728,10 +725,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     t->incoming_stream = s;
   }
   DCHECK_NE(s, nullptr);
-  s->stats.incoming.framing_bytes += 9;
+  s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   if (GPR_UNLIKELY(s->read_closed)) {
-    GRPC_CHTTP2_IF_TRACING(gpr_log(
-        GPR_ERROR, "skipping already closed grpc_chttp2_stream header"));
+    GRPC_CHTTP2_IF_TRACING(ERROR)
+        << "skipping already closed grpc_chttp2_stream header";
     t->incoming_stream = nullptr;
     return init_header_skip_frame_parser(t, priority_type, is_eoh);
   }
@@ -745,7 +742,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   switch (s->header_frames_received) {
     case 0:
       if (t->is_client && t->header_eof) {
-        GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing Trailers-Only"));
+        GRPC_CHTTP2_IF_TRACING(INFO) << "parsing Trailers-Only";
         if (s->trailing_metadata_available != nullptr) {
           *s->trailing_metadata_available = true;
         }
@@ -755,13 +752,13 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         incoming_metadata_buffer = &s->trailing_metadata_buffer;
         frame_type = HPackParser::LogInfo::kTrailers;
       } else {
-        GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing initial_metadata"));
+        GRPC_CHTTP2_IF_TRACING(INFO) << "parsing initial_metadata";
         incoming_metadata_buffer = &s->initial_metadata_buffer;
         frame_type = HPackParser::LogInfo::kHeaders;
       }
       break;
     case 1:
-      GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing trailing_metadata"));
+      GRPC_CHTTP2_IF_TRACING(INFO) << "parsing trailing_metadata";
       incoming_metadata_buffer = &s->trailing_metadata_buffer;
       frame_type = HPackParser::LogInfo::kTrailers;
       break;
@@ -794,12 +791,12 @@ static grpc_error_handle init_window_update_frame_parser(
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
     if (s == nullptr) {
       if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        gpr_log(GPR_ERROR, "Stream %d not found, ignoring WINDOW_UPDATE",
-                t->incoming_stream_id);
+        LOG(ERROR) << "Stream " << t->incoming_stream_id
+                   << " not found, ignoring WINDOW_UPDATE";
       }
       return init_non_header_skip_frame_parser(t);
     }
-    s->stats.incoming.framing_bytes += 9;
+    s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   }
   t->parser = grpc_chttp2_transport::Parser{
       "window_update", grpc_chttp2_window_update_parser_parse,
@@ -825,7 +822,7 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   if (!t->incoming_stream) {
     return init_non_header_skip_frame_parser(t);
   }
-  s->stats.incoming.framing_bytes += 9;
+  s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   t->parser = grpc_chttp2_transport::Parser{
       "rst_stream", grpc_chttp2_rst_stream_parser_parse, &t->simple.rst_stream};
   if (!t->is_client && grpc_core::IsRstpitEnabled()) {
@@ -896,8 +893,8 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
     return err;
   }
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_ERROR, "INCOMING[%p;%p]: Parse failed with %s", t, s,
-            err.ToString().c_str());
+    LOG(ERROR) << "INCOMING[" << t << ";" << s << "]: Parse failed with "
+               << err;
   }
   if (grpc_error_get_int(err, grpc_core::StatusIntProperty::kStreamId,
                          &unused)) {
@@ -921,7 +918,7 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
   grpc_chttp2_transport* t = s->t.get();
   if (!s->write_closed) {
     grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
-                                             &s->stats.outgoing);
+                                             &s->call_tracer_wrapper);
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
     grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
   }
@@ -936,9 +933,12 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
   auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
   grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
   if (s != nullptr) {
-    s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
+    s->call_tracer_wrapper.RecordIncomingBytes(
+        {0, 0, GRPC_SLICE_LENGTH(slice)});
     call_tracer =
-        s->arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
+        grpc_core::IsCallTracerInTransportEnabled()
+            ? s->arena->GetContext<grpc_core::CallTracerInterface>()
+            : s->arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
   }
   grpc_error_handle error = parser->Parse(
       slice, is_last != 0, absl::BitGenRef(t->bitgen), call_tracer);

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

@@ -17,8 +17,8 @@
 //
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
@@ -69,8 +69,8 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
   }
   *stream = s;
   if (s && GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
-    gpr_log(GPR_INFO, "%p[%d][%s]: pop from %s", t, s->id,
-            t->is_client ? "cli" : "svr", stream_list_id_string(id));
+    LOG(INFO) << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+              << "]: pop from " << stream_list_id_string(id);
   }
   return s != nullptr;
 }
@@ -91,8 +91,8 @@ static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
     t->lists[id].tail = s->links[id].prev;
   }
   if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
-    gpr_log(GPR_INFO, "%p[%d][%s]: remove from %s", t, s->id,
-            t->is_client ? "cli" : "svr", stream_list_id_string(id));
+    LOG(INFO) << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+              << "]: remove from " << stream_list_id_string(id);
   }
 }
 
@@ -123,8 +123,8 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
   t->lists[id].tail = s;
   s->included.set(id);
   if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
-    gpr_log(GPR_INFO, "%p[%d][%s]: add to %s", t, s->id,
-            t->is_client ? "cli" : "svr", stream_list_id_string(id));
+    LOG(INFO) << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+              << "]: add to " << stream_list_id_string(id);
   }
 }