grpc 1.65.2 → 1.66.0.pre3

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

@@ -53,7 +53,6 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
@@ -84,6 +83,7 @@
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
@@ -257,6 +257,7 @@ grpc_core::CopyContextFn g_get_copied_context_fn = nullptr;
 namespace grpc_core {
 
 namespace {
+
 // Initialize a grpc_closure \a c to call \a Fn with \a t and \a error. Holds
 // the passed in reference to \a t until it's moved into Fn.
 template <void (*Fn)(RefCountedPtr<grpc_chttp2_transport>, grpc_error_handle)>
@@ -272,13 +273,12 @@ grpc_closure* InitTransportClosure(RefCountedPtr<grpc_chttp2_transport> t,
       t.release(), nullptr);
   return c;
 }
-}  // namespace
 
-namespace {
 TestOnlyGlobalHttp2TransportInitCallback test_only_init_callback = nullptr;
 TestOnlyGlobalHttp2TransportDestructCallback test_only_destruct_callback =
     nullptr;
 bool test_only_disable_transient_failure_state_notification = false;
+
 }  // namespace
 
 void TestOnlySetGlobalHttp2TransportInitCallback(
@@ -361,6 +361,34 @@ std::string HttpAnnotation::ToString() const {
   return s;
 }
 
+void Chttp2CallTracerWrapper::RecordIncomingBytes(
+    const CallTracerInterface::TransportByteSize& transport_byte_size) {
+  // Update legacy API.
+  stream_->stats.incoming.framing_bytes += transport_byte_size.framing_bytes;
+  stream_->stats.incoming.data_bytes += transport_byte_size.data_bytes;
+  stream_->stats.incoming.header_bytes += transport_byte_size.header_bytes;
+  // Update new API.
+  if (!IsCallTracerInTransportEnabled()) return;
+  auto* call_tracer = stream_->arena->GetContext<CallTracerInterface>();
+  if (call_tracer != nullptr) {
+    call_tracer->RecordIncomingBytes(transport_byte_size);
+  }
+}
+
+void Chttp2CallTracerWrapper::RecordOutgoingBytes(
+    const CallTracerInterface::TransportByteSize& transport_byte_size) {
+  // Update legacy API.
+  stream_->stats.outgoing.framing_bytes += transport_byte_size.framing_bytes;
+  stream_->stats.outgoing.data_bytes += transport_byte_size.data_bytes;
+  stream_->stats.outgoing.header_bytes +=
+      transport_byte_size.header_bytes;  // Update new API.
+  if (!IsCallTracerInTransportEnabled()) return;
+  auto* call_tracer = stream_->arena->GetContext<CallTracerInterface>();
+  if (call_tracer != nullptr) {
+    call_tracer->RecordOutgoingBytes(transport_byte_size);
+  }
+}
+
 }  // namespace grpc_core
 
 //
@@ -378,8 +406,6 @@ grpc_chttp2_transport::~grpc_chttp2_transport() {
     channelz_socket.reset();
   }
 
-  if (ep != nullptr) grpc_endpoint_destroy(ep);
-
   grpc_slice_buffer_destroy(&qbuf);
 
   grpc_error_handle error = GRPC_ERROR_CREATE("Transport destroyed");
@@ -420,9 +446,9 @@ static void read_channel_args(grpc_chttp2_transport* t,
       channel_args.GetInt(GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER).value_or(-1);
   if (initial_sequence_number > 0) {
     if ((t->next_stream_id & 1) != (initial_sequence_number & 1)) {
-      gpr_log(GPR_ERROR, "%s: low bit must be %d on %s",
-              GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER, t->next_stream_id & 1,
-              is_client ? "client" : "server");
+      LOG(ERROR) << GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER
+                 << ": low bit must be " << (t->next_stream_id & 1) << " on "
+                 << (is_client ? "client" : "server");
     } else {
       t->next_stream_id = static_cast<uint32_t>(initial_sequence_number);
     }
@@ -458,15 +484,11 @@ static void read_channel_args(grpc_chttp2_transport* t,
   if (t->is_client) {
     t->keepalive_permit_without_calls =
         channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
-            .value_or(grpc_core::IsKeepaliveFixEnabled()
-                          ? g_default_client_keepalive_permit_without_calls
-                          : false);
+            .value_or(g_default_client_keepalive_permit_without_calls);
   } else {
     t->keepalive_permit_without_calls =
         channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
-            .value_or(grpc_core::IsKeepaliveServerFixEnabled()
-                          ? g_default_server_keepalive_permit_without_calls
-                          : false);
+            .value_or(g_default_server_keepalive_permit_without_calls);
   }
 
   t->settings_timeout =
@@ -495,7 +517,7 @@ static void read_channel_args(grpc_chttp2_transport* t,
           .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
     t->channelz_socket =
         grpc_core::MakeRefCounted<grpc_core::channelz::SocketNode>(
-            std::string(grpc_endpoint_get_local_address(t->ep)),
+            std::string(grpc_endpoint_get_local_address(t->ep.get())),
             std::string(t->peer_string.as_string_view()),
             absl::StrCat(t->GetTransportName(), " ",
                          t->peer_string.as_string_view()),
@@ -528,8 +550,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
       t->max_concurrent_streams_policy.SetTarget(value);
     }
   } else if (channel_args.Contains(GRPC_ARG_MAX_CONCURRENT_STREAMS)) {
-    gpr_log(GPR_DEBUG, "%s is not available on clients",
-            GRPC_ARG_MAX_CONCURRENT_STREAMS);
+    VLOG(2) << GRPC_ARG_MAX_CONCURRENT_STREAMS
+            << " is not available on clients";
   }
   value =
       channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER).value_or(-1);
@@ -589,11 +611,11 @@ using grpc_event_engine::experimental::QueryExtension;
 using grpc_event_engine::experimental::TcpTraceExtension;
 
 grpc_chttp2_transport::grpc_chttp2_transport(
-    const grpc_core::ChannelArgs& channel_args, grpc_endpoint* ep,
-    bool is_client)
-    : ep(ep),
+    const grpc_core::ChannelArgs& channel_args,
+    grpc_core::OrphanablePtr<grpc_endpoint> endpoint, bool is_client)
+    : ep(std::move(endpoint)),
       peer_string(
-          grpc_core::Slice::FromCopiedString(grpc_endpoint_get_peer(ep))),
+          grpc_core::Slice::FromCopiedString(grpc_endpoint_get_peer(ep.get()))),
       memory_owner(channel_args.GetObject<grpc_core::ResourceQuota>()
                        ->memory_quota()
                        ->CreateMemoryOwner()),
@@ -617,10 +639,11 @@ grpc_chttp2_transport::grpc_chttp2_transport(
   context_list = new grpc_core::ContextList();
 
   if (channel_args.GetBool(GRPC_ARG_TCP_TRACING_ENABLED).value_or(false) &&
-      grpc_event_engine::experimental::grpc_is_event_engine_endpoint(ep)) {
+      grpc_event_engine::experimental::grpc_is_event_engine_endpoint(
+          ep.get())) {
     auto epte = QueryExtension<TcpTraceExtension>(
         grpc_event_engine::experimental::grpc_get_wrapped_event_engine_endpoint(
-            ep));
+            ep.get()));
     if (epte != nullptr) {
       epte->InitializeAndReturnTcpTracer();
     }
@@ -763,17 +786,16 @@ static void close_transport_locked(grpc_chttp2_transport* t,
     CHECK(t->write_state == GRPC_CHTTP2_WRITE_STATE_IDLE);
     if (t->interested_parties_until_recv_settings != nullptr) {
       grpc_endpoint_delete_from_pollset_set(
-          t->ep, t->interested_parties_until_recv_settings);
+          t->ep.get(), t->interested_parties_until_recv_settings);
       t->interested_parties_until_recv_settings = nullptr;
     }
     grpc_core::MutexLock lock(&t->ep_destroy_mu);
-    grpc_endpoint_destroy(t->ep);
-    t->ep = nullptr;
+    t->ep.reset();
   }
   if (t->notify_on_receive_settings != nullptr) {
     if (t->interested_parties_until_recv_settings != nullptr) {
       grpc_endpoint_delete_from_pollset_set(
-          t->ep, t->interested_parties_until_recv_settings);
+          t->ep.get(), t->interested_parties_until_recv_settings);
       t->interested_parties_until_recv_settings = nullptr;
     }
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, t->notify_on_receive_settings,
@@ -820,7 +842,8 @@ grpc_chttp2_stream::grpc_chttp2_stream(grpc_chttp2_transport* t,
         return refcount;
       }()),
       arena(arena),
-      flow_control(&t->flow_control) {
+      flow_control(&t->flow_control),
+      call_tracer_wrapper(this) {
   t->streams_allocated.fetch_add(1, std::memory_order_relaxed);
   if (server_data) {
     id = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(server_data));
@@ -927,11 +950,11 @@ static const char* write_state_name(grpc_chttp2_write_state st) {
 
 static void set_write_state(grpc_chttp2_transport* t,
                             grpc_chttp2_write_state st, const char* reason) {
-  GRPC_CHTTP2_IF_TRACING(
-      gpr_log(GPR_INFO, "W:%p %s [%s] state %s -> %s [%s]", t,
-              t->is_client ? "CLIENT" : "SERVER",
-              std::string(t->peer_string.as_string_view()).c_str(),
-              write_state_name(t->write_state), write_state_name(st), reason));
+  GRPC_TRACE_LOG(http, INFO)
+      << "W:" << t << " " << (t->is_client ? "CLIENT" : "SERVER") << " ["
+      << t->peer_string.as_string_view() << "] state "
+      << write_state_name(t->write_state) << " -> " << write_state_name(st)
+      << " [" << reason << "]";
   t->write_state = st;
   // If the state is being reset back to idle, it means a write was just
   // finished. Make sure all the run_after_write closures are scheduled.
@@ -1021,11 +1044,10 @@ static void write_action_begin_locked(
       // We had paused reading, because we had many induced frames (SETTINGS
       // ACK, PINGS ACK and RST_STREAMS) pending in t->qbuf. Now that we have
       // been able to flush qbuf, we can resume reading.
-      GRPC_CHTTP2_IF_TRACING(gpr_log(
-          GPR_INFO,
-          "transport %p : Resuming reading after being paused due to too "
-          "many unwritten SETTINGS ACK, PINGS ACK and RST_STREAM frames",
-          t.get()));
+      GRPC_TRACE_LOG(http, INFO)
+          << "transport " << t.get()
+          << " : Resuming reading after being paused due to too many unwritten "
+             "SETTINGS ACK, PINGS ACK and RST_STREAM frames";
       t->reading_paused_on_pending_induced_frames = false;
       continue_read_action_locked(std::move(t));
     }
@@ -1061,7 +1083,7 @@ static void write_action(grpc_chttp2_transport* t) {
       << (t->is_client ? "CLIENT" : "SERVER") << "[" << t << "]: Write "
       << t->outbuf.Length() << " bytes";
   t->write_size_policy.BeginWrite(t->outbuf.Length());
-  grpc_endpoint_write(t->ep, t->outbuf.c_slice_buffer(),
+  grpc_endpoint_write(t->ep.get(), t->outbuf.c_slice_buffer(),
                       grpc_core::InitTransportClosure<write_action_end>(
                           t->Ref(), &t->write_action_end_locked),
                       cl, max_frame_size);
@@ -1152,15 +1174,15 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
           static_cast<intptr_t>(goaway_error)),
       grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
 
-  GRPC_CHTTP2_IF_TRACING(
-      gpr_log(GPR_INFO, "transport %p got goaway with last stream id %d", t,
-              last_stream_id));
+  GRPC_TRACE_LOG(http, INFO)
+      << "transport " << t << " got goaway with last stream id "
+      << last_stream_id;
   // We want to log this irrespective of whether http tracing is enabled if we
   // received a GOAWAY with a non NO_ERROR code.
   if (goaway_error != GRPC_HTTP2_NO_ERROR) {
-    gpr_log(GPR_INFO, "%s: Got goaway [%d] err=%s",
-            std::string(t->peer_string.as_string_view()).c_str(), goaway_error,
-            grpc_core::StatusToString(t->goaway_error).c_str());
+    LOG(INFO) << t->peer_string.as_string_view() << ": Got goaway ["
+              << goaway_error
+              << "] err=" << grpc_core::StatusToString(t->goaway_error);
   }
   if (t->is_client) {
     cancel_unstarted_streams(t, t->goaway_error, false);
@@ -1186,12 +1208,11 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
   if (GPR_UNLIKELY(t->is_client &&
                    goaway_error == GRPC_HTTP2_ENHANCE_YOUR_CALM &&
                    goaway_text == "too_many_pings")) {
-    gpr_log(GPR_ERROR,
-            "%s: Received a GOAWAY with error code ENHANCE_YOUR_CALM and debug "
-            "data equal to \"too_many_pings\". Current keepalive time (before "
-            "throttling): %s",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            t->keepalive_time.ToString().c_str());
+    LOG(ERROR) << t->peer_string.as_string_view()
+               << ": Received a GOAWAY with error code ENHANCE_YOUR_CALM and "
+                  "debug data equal to \"too_many_pings\". Current keepalive "
+                  "time (before throttling): "
+               << t->keepalive_time.ToString();
     constexpr int max_keepalive_time_millis =
         INT_MAX / KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
     int64_t throttled_keepalive_time =
@@ -1223,10 +1244,10 @@ static void maybe_start_some_streams(grpc_chttp2_transport* t) {
          t->stream_map.size() < t->settings.peer().max_concurrent_streams() &&
          grpc_chttp2_list_pop_waiting_for_concurrency(t, &s)) {
     // safe since we can't (legally) be parsing this stream yet
-    GRPC_CHTTP2_IF_TRACING(gpr_log(
-        GPR_INFO,
-        "HTTP:%s: Transport %p allocating new grpc_chttp2_stream %p to id %d",
-        t->is_client ? "CLI" : "SVR", t, s, t->next_stream_id));
+    GRPC_TRACE_LOG(http, INFO)
+        << "HTTP:" << (t->is_client ? "CLI" : "SVR") << ": Transport " << t
+        << " allocating new grpc_chttp2_stream " << s << " to id "
+        << t->next_stream_id;
 
     CHECK_EQ(s->id, 0u);
     s->id = t->next_stream_id;
@@ -1289,17 +1310,13 @@ void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
   }
   closure->next_data.scratch -= CLOSURE_BARRIER_FIRST_REF_BIT;
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(
-        GPR_INFO,
-        "complete_closure_step: t=%p %p refs=%d flags=0x%04x desc=%s err=%s "
-        "write_state=%s whence=%s:%d",
-        t, closure,
-        static_cast<int>(closure->next_data.scratch /
-                         CLOSURE_BARRIER_FIRST_REF_BIT),
-        static_cast<int>(closure->next_data.scratch %
-                         CLOSURE_BARRIER_FIRST_REF_BIT),
-        desc, grpc_core::StatusToString(error).c_str(),
-        write_state_name(t->write_state), whence.file(), whence.line());
+    LOG(INFO) << "complete_closure_step: t=" << t << " " << closure << " refs="
+              << (closure->next_data.scratch / CLOSURE_BARRIER_FIRST_REF_BIT)
+              << " flags="
+              << (closure->next_data.scratch % CLOSURE_BARRIER_FIRST_REF_BIT)
+              << " desc=" << desc << " err=" << grpc_core::StatusToString(error)
+              << " write_state=" << write_state_name(t->write_state)
+              << " whence=" << whence.file() << ":" << whence.line();
   }
 
   if (!error.ok()) {
@@ -1342,7 +1359,7 @@ static void log_metadata(const grpc_metadata_batch* md_batch, uint32_t id,
   const std::string prefix = absl::StrCat(
       "HTTP:", id, is_initial ? ":HDR" : ":TRL", is_client ? ":CLI:" : ":SVR:");
   md_batch->Log([&prefix](absl::string_view key, absl::string_view value) {
-    VLOG(2) << absl::StrCat(prefix, key, ": ", value);
+    VLOG(2) << prefix << key << ": " << value;
   });
 }
 
@@ -1356,13 +1373,14 @@ static void perform_stream_op_locked(void* stream_op,
   grpc_chttp2_transport* t = s->t.get();
 
   s->traced = op->is_traced;
-  s->call_tracer = CallTracerIfSampled(s);
+  if (!grpc_core::IsCallTracerInTransportEnabled()) {
+    s->call_tracer = CallTracerIfSampled(s);
+  }
   s->tcp_tracer = TcpTracerIfSampled(s);
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_INFO,
-            "perform_stream_op_locked[s=%p; op=%p]: %s; on_complete = %p", s,
-            op, grpc_transport_stream_op_batch_string(op, false).c_str(),
-            op->on_complete);
+    LOG(INFO) << "perform_stream_op_locked[s=" << s << "; op=" << op
+              << "]: " << grpc_transport_stream_op_batch_string(op, false)
+              << "; on_complete = " << op->on_complete;
     if (op->send_initial_metadata) {
       log_metadata(op_payload->send_initial_metadata.send_initial_metadata,
                    s->id, t->is_client, true);
@@ -1388,12 +1406,24 @@ static void perform_stream_op_locked(void* stream_op,
   }
 
   if (op->send_initial_metadata) {
-    if (s->call_tracer != nullptr) {
-      s->call_tracer->RecordAnnotation(
-          grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kStart,
-                                    gpr_now(GPR_CLOCK_REALTIME))
-              .Add(s->t->flow_control.stats())
-              .Add(s->flow_control.stats()));
+    if (!grpc_core::IsCallTracerInTransportEnabled()) {
+      if (s->call_tracer != nullptr) {
+        s->call_tracer->RecordAnnotation(
+            grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kStart,
+                                      gpr_now(GPR_CLOCK_REALTIME))
+                .Add(s->t->flow_control.stats())
+                .Add(s->flow_control.stats()));
+      }
+    } else if (grpc_core::IsTraceRecordCallopsEnabled()) {
+      auto* call_tracer =
+          s->arena->GetContext<grpc_core::CallTracerInterface>();
+      if (call_tracer != nullptr && call_tracer->IsSampled()) {
+        call_tracer->RecordAnnotation(
+            grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kStart,
+                                      gpr_now(GPR_CLOCK_REALTIME))
+                .Add(s->t->flow_control.stats())
+                .Add(s->flow_control.stats()));
+      }
     }
     if (t->is_client && t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromLocal();
@@ -1477,11 +1507,8 @@ static void perform_stream_op_locked(void* stream_op,
       frame_hdr[3] = static_cast<uint8_t>(len >> 8);
       frame_hdr[4] = static_cast<uint8_t>(len);
 
-      if (grpc_core::IsHttp2StatsFixEnabled()) {
-        s->stats.outgoing.framing_bytes += GRPC_HEADER_SIZE_IN_BYTES;
-        s->stats.outgoing.data_bytes +=
-            op_payload->send_message.send_message->Length();
-      }
+      s->call_tracer_wrapper.RecordOutgoingBytes(
+          {GRPC_HEADER_SIZE_IN_BYTES, len, 0});
       s->next_message_end_offset =
           s->flow_controlled_bytes_written +
           static_cast<int64_t>(s->flow_controlled_buffer.length) +
@@ -1626,8 +1653,8 @@ void grpc_chttp2_transport::PerformStreamOp(
   }
 
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_INFO, "perform_stream_op[s=%p; op=%p]: %s", s, op,
-            grpc_transport_stream_op_batch_string(op, false).c_str());
+    LOG(INFO) << "perform_stream_op[s=" << s << "; op=" << op
+              << "]: " << grpc_transport_stream_op_batch_string(op, false);
   }
 
   GRPC_CHTTP2_STREAM_REF(s, "perform_stream_op");
@@ -1638,8 +1665,8 @@ void grpc_chttp2_transport::PerformStreamOp(
 }
 
 static void cancel_pings(grpc_chttp2_transport* t, grpc_error_handle error) {
-  GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "%p CANCEL PINGS: %s", t,
-                                 grpc_core::StatusToString(error).c_str()));
+  GRPC_TRACE_LOG(http, INFO)
+      << t << " CANCEL PINGS: " << grpc_core::StatusToString(error);
   // callback remaining pings: they're not allowed to call into the transport,
   //   and maybe they hold resources that need to be freed
   t->ping_callbacks.CancelAll(t->event_engine.get());
@@ -1722,8 +1749,8 @@ static void retry_initiate_ping_locked(
 
 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id) {
   if (!t->ping_callbacks.AckPing(id, t->event_engine.get())) {
-    gpr_log(GPR_DEBUG, "Unknown ping response from %s: %" PRIx64,
-            std::string(t->peer_string.as_string_view()).c_str(), id);
+    VLOG(2) << "Unknown ping response from " << t->peer_string.as_string_view()
+            << ": " << id;
     return;
   }
   if (t->ping_callbacks.ping_requested()) {
@@ -1828,22 +1855,21 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
       return;
     }
     if (t_->destroying || !t_->closed_with_error.ok()) {
-      GRPC_CHTTP2_IF_TRACING(
-          gpr_log(GPR_INFO,
-                  "transport:%p %s peer:%s Transport already shutting down. "
-                  "Graceful GOAWAY abandoned.",
-                  t_.get(), t_->is_client ? "CLIENT" : "SERVER",
-                  std::string(t_->peer_string.as_string_view()).c_str()));
+      GRPC_TRACE_LOG(http, INFO) << "transport:" << t_.get() << " "
+                                 << (t_->is_client ? "CLIENT" : "SERVER")
+                                 << " peer:" << t_->peer_string.as_string_view()
+                                 << " Transport already shutting down. "
+                                    "Graceful GOAWAY abandoned.";
       return;
     }
     // Ping completed. Send final goaway.
-    GRPC_CHTTP2_IF_TRACING(
-        gpr_log(GPR_INFO,
-                "transport:%p %s peer:%s Graceful shutdown: Ping received. "
-                "Sending final GOAWAY with stream_id:%d",
-                t_.get(), t_->is_client ? "CLIENT" : "SERVER",
-                std::string(t_->peer_string.as_string_view()).c_str(),
-                t_->last_new_stream_id));
+    GRPC_TRACE_LOG(http, INFO)
+        << "transport:" << t_.get() << " "
+        << (t_->is_client ? "CLIENT" : "SERVER")
+        << " peer:" << std::string(t_->peer_string.as_string_view())
+        << " Graceful shutdown: Ping received. "
+           "Sending final GOAWAY with stream_id:"
+        << t_->last_new_stream_id;
     t_->sent_goaway_state = GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED;
     grpc_chttp2_goaway_append(t_->last_new_stream_id, 0, grpc_empty_slice(),
                               &t_->qbuf);
@@ -1887,10 +1913,10 @@ static void send_goaway(grpc_chttp2_transport* t, grpc_error_handle error,
   } else if (t->sent_goaway_state == GRPC_CHTTP2_NO_GOAWAY_SEND ||
              t->sent_goaway_state == GRPC_CHTTP2_GRACEFUL_GOAWAY) {
     // We want to log this irrespective of whether http tracing is enabled
-    gpr_log(GPR_DEBUG, "%s %s: Sending goaway last_new_stream_id=%d err=%s",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            t->is_client ? "CLIENT" : "SERVER", t->last_new_stream_id,
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << t->peer_string.as_string_view() << " "
+            << (t->is_client ? "CLIENT" : "SERVER")
+            << ": Sending goaway last_new_stream_id=" << t->last_new_stream_id
+            << " err=" << grpc_core::StatusToString(error);
     t->sent_goaway_state = GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED;
     grpc_chttp2_goaway_append(
         t->last_new_stream_id, static_cast<uint32_t>(http_error),
@@ -1938,11 +1964,15 @@ static void perform_transport_op_locked(void* stream_op,
   }
 
   if (op->bind_pollset) {
-    grpc_endpoint_add_to_pollset(t->ep, op->bind_pollset);
+    if (t->ep != nullptr) {
+      grpc_endpoint_add_to_pollset(t->ep.get(), op->bind_pollset);
+    }
   }
 
   if (op->bind_pollset_set) {
-    grpc_endpoint_add_to_pollset_set(t->ep, op->bind_pollset_set);
+    if (t->ep != nullptr) {
+      grpc_endpoint_add_to_pollset_set(t->ep.get(), op->bind_pollset_set);
+    }
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
@@ -1970,8 +2000,8 @@ static void perform_transport_op_locked(void* stream_op,
 
 void grpc_chttp2_transport::PerformOp(grpc_transport_op* op) {
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_INFO, "perform_transport_op[t=%p]: %s", this,
-            grpc_transport_op_string(op).c_str());
+    LOG(INFO) << "perform_transport_op[t=" << this
+              << "]: " << grpc_transport_op_string(op);
   }
   op->handler_private.extra_arg = this;
   Ref().release()->combiner->Run(
@@ -2023,10 +2053,9 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
   // exited out of at any point by returning.
   [&]() {
     if (GRPC_TRACE_FLAG_ENABLED(http)) {
-      gpr_log(GPR_DEBUG,
-              "maybe_complete_recv_message %p final_metadata_requested=%d "
-              "seen_error=%d",
-              s, s->final_metadata_requested, s->seen_error);
+      VLOG(2) << "maybe_complete_recv_message " << s
+              << " final_metadata_requested=" << s->final_metadata_requested
+              << " seen_error=" << s->seen_error;
     }
     if (s->final_metadata_requested && s->seen_error) {
       grpc_slice_buffer_reset_and_unref(&s->frame_storage);
@@ -2039,10 +2068,9 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
           auto r = grpc_deframe_unprocessed_incoming_frames(
               s, &min_progress_size, &**s->recv_message, s->recv_message_flags);
           if (GRPC_TRACE_FLAG_ENABLED(http)) {
-            gpr_log(GPR_DEBUG, "Deframe data frame: %s",
-                    grpc_core::PollToString(r, [](absl::Status r) {
-                      return r.ToString();
-                    }).c_str());
+            VLOG(2) << "Deframe data frame: "
+                    << grpc_core::PollToString(
+                           r, [](absl::Status r) { return r.ToString(); });
           }
           if (r.pending()) {
             if (s->read_closed) {
@@ -2095,12 +2123,11 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_chttp2_transport* t,
                                                        grpc_chttp2_stream* s) {
   grpc_chttp2_maybe_complete_recv_message(t, s);
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_DEBUG,
-            "maybe_complete_recv_trailing_metadata cli=%d s=%p closure=%p "
-            "read_closed=%d "
-            "write_closed=%d %" PRIdPTR,
-            t->is_client, s, s->recv_trailing_metadata_finished, s->read_closed,
-            s->write_closed, s->frame_storage.length);
+    VLOG(2) << "maybe_complete_recv_trailing_metadata cli=" << t->is_client
+            << " s=" << s << " closure=" << s->recv_trailing_metadata_finished
+            << " read_closed=" << s->read_closed
+            << " write_closed=" << s->write_closed << " "
+            << s->frame_storage.length;
   }
   if (s->recv_trailing_metadata_finished != nullptr && s->read_closed &&
       s->write_closed) {
@@ -2306,12 +2333,13 @@ grpc_chttp2_transport::RemovedStreamHandle grpc_chttp2_mark_stream_closed(
     int close_writes, grpc_error_handle error) {
   grpc_chttp2_transport::RemovedStreamHandle rsh;
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(
-        GPR_DEBUG, "MARK_STREAM_CLOSED: t=%p s=%p(id=%d) %s [%s]", t, s, s->id,
-        (close_reads && close_writes)
-            ? "read+write"
-            : (close_reads ? "read" : (close_writes ? "write" : "nothing??")),
-        grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "MARK_STREAM_CLOSED: t=" << t << " s=" << s << "(id=" << s->id
+            << ") "
+            << ((close_reads && close_writes)
+                    ? "read+write"
+                    : (close_reads ? "read"
+                                   : (close_writes ? "write" : "nothing??")))
+            << " [" << grpc_core::StatusToString(error) << "]";
   }
   if (s->read_closed && s->write_closed) {
     // already closed, but we should still fake the status if needed.
@@ -2719,11 +2747,10 @@ static void read_action_parse_loop_locked(
   if (keep_reading) {
     if (t->num_pending_induced_frames >= DEFAULT_MAX_PENDING_INDUCED_FRAMES) {
       t->reading_paused_on_pending_induced_frames = true;
-      GRPC_CHTTP2_IF_TRACING(
-          gpr_log(GPR_INFO,
-                  "transport %p : Pausing reading due to too "
-                  "many unwritten SETTINGS ACK and RST_STREAM frames",
-                  t.get()));
+      GRPC_TRACE_LOG(http, INFO)
+          << "transport " << t.get()
+          << " : Pausing reading due to too many unwritten "
+             "SETTINGS ACK and RST_STREAM frames";
     } else {
       continue_read_action_locked(std::move(t));
     }
@@ -2738,9 +2765,8 @@ static void read_action_locked(
   if (t->keepalive_ping_timeout_handle != TaskHandle::kInvalid) {
     if (GRPC_TRACE_FLAG_ENABLED(http2_ping) ||
         GRPC_TRACE_FLAG_ENABLED(http_keepalive)) {
-      gpr_log(GPR_INFO,
-              "%s[%p]: Clear keepalive timer because data was received",
-              t->is_client ? "CLIENT" : "SERVER", t.get());
+      LOG(INFO) << (t->is_client ? "CLIENT" : "SERVER") << "[" << t.get()
+                << "]: Clear keepalive timer because data was received";
     }
     t->event_engine->Cancel(
         std::exchange(t->keepalive_ping_timeout_handle, TaskHandle::kInvalid));
@@ -2759,7 +2785,7 @@ static void continue_read_action_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t) {
   const bool urgent = !t->goaway_error.ok();
   auto* tp = t.get();
-  grpc_endpoint_read(tp->ep, &tp->read_buffer,
+  grpc_endpoint_read(tp->ep.get(), &tp->read_buffer,
                      grpc_core::InitTransportClosure<read_action>(
                          std::move(t), &tp->read_action_locked),
                      urgent, grpc_chttp2_min_read_progress_size(tp));
@@ -2791,9 +2817,8 @@ static void start_bdp_ping_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t,
     grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_INFO, "%s: Start BDP ping err=%s",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << t->peer_string.as_string_view()
+              << ": Start BDP ping err=" << grpc_core::StatusToString(error);
   }
   if (!error.ok() || !t->closed_with_error.ok()) {
     return;
@@ -2818,9 +2843,8 @@ static void finish_bdp_ping_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t,
     grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    gpr_log(GPR_INFO, "%s: Complete BDP ping err=%s",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << t->peer_string.as_string_view()
+              << ": Complete BDP ping err=" << grpc_core::StatusToString(error);
   }
   if (!error.ok() || !t->closed_with_error.ok()) {
     return;
@@ -2963,8 +2987,8 @@ static void finish_keepalive_ping_locked(
     if (error.ok()) {
       if (GRPC_TRACE_FLAG_ENABLED(http) ||
           GRPC_TRACE_FLAG_ENABLED(http_keepalive)) {
-        gpr_log(GPR_INFO, "%s: Finish keepalive ping",
-                std::string(t->peer_string.as_string_view()).c_str());
+        LOG(INFO) << t->peer_string.as_string_view()
+                  << ": Finish keepalive ping";
       }
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_WAITING;
       CHECK(t->keepalive_ping_timer_handle == TaskHandle::kInvalid);
@@ -2985,8 +3009,8 @@ static void maybe_reset_keepalive_ping_timer_locked(grpc_chttp2_transport* t) {
     // need to Ref or Unref here since we still hold the Ref.
     if (GRPC_TRACE_FLAG_ENABLED(http) ||
         GRPC_TRACE_FLAG_ENABLED(http_keepalive)) {
-      gpr_log(GPR_INFO, "%s: Keepalive ping cancelled. Resetting timer.",
-              std::string(t->peer_string.as_string_view()).c_str());
+      LOG(INFO) << t->peer_string.as_string_view()
+                << ": Keepalive ping cancelled. Resetting timer.";
     }
     t->keepalive_ping_timer_handle =
         t->event_engine->RunAfter(t->keepalive_time, [t = t->Ref()]() mutable {
@@ -3005,9 +3029,9 @@ static void connectivity_state_set(grpc_chttp2_transport* t,
                                    grpc_connectivity_state state,
                                    const absl::Status& status,
                                    const char* reason) {
-  GRPC_CHTTP2_IF_TRACING(gpr_log(
-      GPR_INFO, "transport %p set connectivity_state=%d; status=%s; reason=%s",
-      t, state, status.ToString().c_str(), reason));
+  GRPC_TRACE_LOG(http, INFO)
+      << "transport " << t << " set connectivity_state=" << state
+      << "; status=" << status.ToString() << "; reason=" << reason;
   t->state_tracker.SetState(state, status, reason);
 }
 
@@ -3022,7 +3046,7 @@ void grpc_chttp2_transport::SetPollset(grpc_stream* /*gs*/,
   // actually uses pollsets.
   if (strcmp(grpc_get_poll_strategy_name(), "poll") != 0) return;
   grpc_core::MutexLock lock(&ep_destroy_mu);
-  if (ep != nullptr) grpc_endpoint_add_to_pollset(ep, pollset);
+  if (ep != nullptr) grpc_endpoint_add_to_pollset(ep.get(), pollset);
 }
 
 void grpc_chttp2_transport::SetPollsetSet(grpc_stream* /*gs*/,
@@ -3032,7 +3056,7 @@ void grpc_chttp2_transport::SetPollsetSet(grpc_stream* /*gs*/,
   // actually uses pollsets.
   if (strcmp(grpc_get_poll_strategy_name(), "poll") != 0) return;
   grpc_core::MutexLock lock(&ep_destroy_mu);
-  if (ep != nullptr) grpc_endpoint_add_to_pollset_set(ep, pollset_set);
+  if (ep != nullptr) grpc_endpoint_add_to_pollset_set(ep.get(), pollset_set);
 }
 
 //
@@ -3084,8 +3108,8 @@ static void benign_reclaimer_locked(
     // Channel with no active streams: send a goaway to try and make it
     // disconnect cleanly
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-      gpr_log(GPR_INFO, "HTTP2: %s - send goaway to free memory",
-              std::string(t->peer_string.as_string_view()).c_str());
+      LOG(INFO) << "HTTP2: " << t->peer_string.as_string_view()
+                << " - send goaway to free memory";
     }
     send_goaway(t.get(),
                 grpc_error_set_int(GRPC_ERROR_CREATE("Buffers full"),
@@ -3093,11 +3117,9 @@ static void benign_reclaimer_locked(
                                    GRPC_HTTP2_ENHANCE_YOUR_CALM),
                 /*immediate_disconnect_hint=*/true);
   } else if (error.ok() && GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    gpr_log(GPR_INFO,
-            "HTTP2: %s - skip benign reclamation, there are still %" PRIdPTR
-            " streams",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            t->stream_map.size());
+    LOG(INFO) << "HTTP2: " << t->peer_string.as_string_view()
+              << " - skip benign reclamation, there are still "
+              << t->stream_map.size() << " streams";
   }
   t->benign_reclaimer_registered = false;
   if (error != absl::CancelledError()) {
@@ -3113,8 +3135,8 @@ static void destructive_reclaimer_locked(
     // As stream_map is a hash map, this selects effectively a random stream.
     grpc_chttp2_stream* s = t->stream_map.begin()->second;
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-      gpr_log(GPR_INFO, "HTTP2: %s - abandon stream id %d",
-              std::string(t->peer_string.as_string_view()).c_str(), s->id);
+      LOG(INFO) << "HTTP2: " << t->peer_string.as_string_view()
+                << " - abandon stream id " << s->id;
     }
     grpc_chttp2_cancel_stream(
         t.get(), s,
@@ -3211,9 +3233,9 @@ grpc_chttp2_transport_get_socket_node(grpc_core::Transport* transport) {
 }
 
 grpc_core::Transport* grpc_create_chttp2_transport(
-    const grpc_core::ChannelArgs& channel_args, grpc_endpoint* ep,
-    bool is_client) {
-  return new grpc_chttp2_transport(channel_args, ep, is_client);
+    const grpc_core::ChannelArgs& channel_args,
+    grpc_core::OrphanablePtr<grpc_endpoint> ep, bool is_client) {
+  return new grpc_chttp2_transport(channel_args, std::move(ep), is_client);
 }
 
 void grpc_chttp2_transport_start_reading(
@@ -3224,7 +3246,6 @@ void grpc_chttp2_transport_start_reading(
   auto t = reinterpret_cast<grpc_chttp2_transport*>(transport)->Ref();
   if (read_buffer != nullptr) {
     grpc_slice_buffer_move_into(read_buffer, &t->read_buffer);
-    gpr_free(read_buffer);
   }
   auto* tp = t.get();
   tp->combiner->Run(
@@ -3236,7 +3257,7 @@ void grpc_chttp2_transport_start_reading(
             if (t->ep != nullptr &&
                 interested_parties_until_recv_settings != nullptr) {
               grpc_endpoint_delete_from_pollset_set(
-                  t->ep, interested_parties_until_recv_settings);
+                  t->ep.get(), interested_parties_until_recv_settings);
             }
             grpc_core::ExecCtx::Run(DEBUG_LOCATION, notify_on_receive_settings,
                                     t->closed_with_error);