grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -19,6 +19,7 @@
 #include <map>
 #include <string>
 
+#include "src/core/channelz/property_list.h"
 #include "src/core/channelz/ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 
@@ -27,7 +28,7 @@ namespace http2_ztrace_collector_detail {
 
 class Config {
  public:
-  explicit Config(std::map<std::string, std::string>) {}
+  explicit Config(const channelz::ZTrace::Args&) {}
 
   template <typename T>
   bool Finishes(const T&) {
@@ -43,12 +44,13 @@ struct H2DataTrace {
   bool end_stream;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("DATA");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["end_stream"] = Json::FromBool(end_stream);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "DATA")
+        .Set("stream_id", stream_id)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -60,14 +62,14 @@ struct H2HeaderTrace {
   bool continuation;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = continuation ? Json::FromString("CONTINUATION")
-                                      : Json::FromString("HEADERS");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["end_headers"] = Json::FromBool(end_headers);
-    json["end_stream"] = Json::FromBool(end_stream);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", continuation ? "CONTINUATION" : "HEADERS")
+        .Set("stream_id", stream_id)
+        .Set("end_headers", end_headers)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -76,11 +78,12 @@ struct H2RstStreamTrace {
   uint32_t stream_id;
   uint32_t error_code;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("RST_STREAM");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["error_code"] = Json::FromNumber(error_code);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "RST_STREAM")
+        .Set("stream_id", stream_id)
+        .Set("error_code", error_code);
   }
 };
 
@@ -89,18 +92,20 @@ struct H2SettingsTrace {
   bool ack;
   std::vector<Http2SettingsFrame::Setting> settings;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("SETTINGS");
-    json["ack"] = Json::FromBool(ack);
-    Json::Array settings_array;
-    for (const auto& setting : settings) {
-      Json::Object setting_object;
-      setting_object["id"] = Json::FromNumber(setting.id);
-      setting_object["value"] = Json::FromNumber(setting.value);
-      settings_array.push_back(Json::FromObject(std::move(setting_object)));
-    }
-    json["settings"] = Json::FromArray(std::move(settings_array));
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SETTINGS")
+        .Set("ack", ack)
+        .Set("settings", [this]() {
+          channelz::PropertyTable table;
+          for (const auto& setting : settings) {
+            table.AppendRow(channelz::PropertyList()
+                                .Set("id", setting.id)
+                                .Set("value", setting.value));
+          }
+          return table;
+        }());
   }
 };
 
@@ -109,11 +114,12 @@ struct H2PingTrace {
   bool ack;
   uint64_t opaque;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("PING");
-    json["ack"] = Json::FromBool(ack);
-    json["opaque"] = Json::FromNumber(opaque);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "PING")
+        .Set("ack", ack)
+        .Set("opaque", opaque);
   }
 };
 
@@ -123,12 +129,13 @@ struct H2GoAwayTrace {
   uint32_t error_code;
   std::string debug_data;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("GOAWAY");
-    json["last_stream_id"] = Json::FromNumber(last_stream_id);
-    json["error_code"] = Json::FromNumber(error_code);
-    json["debug_data"] = Json::FromString(debug_data);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "GOAWAY")
+        .Set("last_stream_id", last_stream_id)
+        .Set("error_code", error_code)
+        .Set("debug_data", debug_data);
   }
 };
 
@@ -137,11 +144,12 @@ struct H2WindowUpdateTrace {
   uint32_t stream_id;
   uint32_t window_size_increment;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("WINDOW_UPDATE");
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["window_size_increment"] = Json::FromNumber(window_size_increment);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "WINDOW_UPDATE")
+        .Set("stream_id", stream_id)
+        .Set("window_size_increment", window_size_increment);
   }
 };
 
@@ -149,10 +157,11 @@ template <bool kRead>
 struct H2SecurityTrace {
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["read"] = Json::FromBool(kRead);
-    json["frame_type"] = Json::FromString("SECURITY");
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SECURITY")
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -162,12 +171,13 @@ struct H2UnknownFrameTrace {
   uint32_t stream_id;
   uint32_t payload_length;
 
-  void RenderJson(Json::Object& json) const {
-    json["frame_type"] = Json::FromString("UNKNOWN");
-    json["type"] = Json::FromNumber(type);
-    json["flags"] = Json::FromNumber(flags);
-    json["stream_id"] = Json::FromNumber(stream_id);
-    json["payload_length"] = Json::FromNumber(payload_length);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "UNKNOWN")
+        .Set("type", type)
+        .Set("flags", flags)
+        .Set("stream_id", stream_id)
+        .Set("payload_length", payload_length);
   }
 };
 
@@ -176,35 +186,38 @@ struct H2FlowControlStall {
   int64_t stream_window;
   uint32_t stream_id;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("FLOW_CONTROL_STALL");
-    json["transport_window"] = Json::FromNumber(transport_window);
-    json["stream_window"] = Json::FromNumber(stream_window);
-    json["stream_id"] = Json::FromNumber(stream_id);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "FLOW_CONTROL_STALL")
+        .Set("transport_window", transport_window)
+        .Set("stream_window", stream_window)
+        .Set("stream_id", stream_id);
   }
 };
 
 struct H2BeginWriteCycle {
   uint32_t target_size;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("BEGIN_WRITE_CYCLE");
-    json["target_size"] = Json::FromNumber(target_size);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_WRITE_CYCLE")
+        .Set("target_size", target_size);
   }
 };
 
 struct H2BeginEndpointWrite {
   uint32_t write_size;
 
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("BEGIN_ENDPOINT_WRITE");
-    json["write_size"] = Json::FromNumber(write_size);
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_ENDPOINT_WRITE")
+        .Set("write_size", write_size);
   }
 };
 
 struct H2EndWriteCycle {
-  void RenderJson(Json::Object& json) const {
-    json["metadata_type"] = Json::FromString("END_WRITE_CYCLE");
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("frame_type", "END_WRITE_CYCLE");
   }
 };
 
@@ -218,6 +231,37 @@ using Http2ZTraceCollector = channelz::ZTraceCollector<
     H2UnknownFrameTrace, H2FlowControlStall, H2BeginWriteCycle, H2EndWriteCycle,
     H2BeginEndpointWrite>;
 
+struct PromiseEndpointReadTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("read_bytes", bytes);
+  }
+};
+
+struct PromiseEndpointWriteTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("written_bytes", bytes);
+  }
+};
+
+namespace promise_http2_ztrace_collector_detail {
+class Config {
+ public:
+  explicit Config(const channelz::ZTrace::Args&) {}
+
+  template <typename T>
+  bool Finishes(const T&) {
+    return false;
+  }
+};
+}  // namespace promise_http2_ztrace_collector_detail
+
+using PromiseHttp2ZTraceCollector =
+    channelz::ZTraceCollector<promise_http2_ztrace_collector_detail::Config,
+                              PromiseEndpointReadTrace,
+                              PromiseEndpointWriteTrace>;
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H

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

@@ -115,6 +115,7 @@ typedef enum {
   GRPC_CHTTP2_WRITE_STATE_WRITING_WITH_MORE,
 } grpc_chttp2_write_state;
 
+// Not getting used anywhere AFAIK
 typedef enum {
   GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY,
   GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT,
@@ -238,7 +239,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
    public:
     explicit ChannelzDataSource(grpc_chttp2_transport* transport)
         : grpc_core::channelz::DataSource(transport->channelz_socket),
-          transport_(transport) {
+          transport_(transport->Ref()) {  // Take a ref
       SourceConstructed();
     }
     ~ChannelzDataSource() { SourceDestructing(); }
@@ -248,7 +249,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
         absl::string_view name) override;
 
    private:
-    grpc_chttp2_transport* transport_;
+    grpc_core::RefCountedPtr<grpc_chttp2_transport> transport_;
   };
 
   void Orphan() override;
@@ -301,6 +302,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::MemoryOwner memory_owner;
   const grpc_core::MemoryAllocator::Reservation self_reservation;
   grpc_core::ReclamationSweep active_reclamation;
+  grpc_core::InstrumentStorageRefPtr<grpc_core::ResourceQuotaDomain>
+      resource_quota_telemetry_storage;
 
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   grpc_core::Combiner* combiner;
@@ -714,7 +717,7 @@ struct grpc_chttp2_stream {
   // annotations as soon as we have parsed initial metadata, but in our legacy
   // stack, we create the stream before parsing headers. In the new v3 stack,
   // that won't be an issue.
-  grpc_core::CallTracerInterface* call_tracer = nullptr;
+  grpc_core::CallTracer* call_tracer = nullptr;
   // TODO(yashykt): Remove this once call_tracer_transport_fix is rolled out
   grpc_core::CallTracerAnnotationInterface* parent_call_tracer = nullptr;
 
@@ -740,17 +743,6 @@ struct grpc_chttp2_stream {
       grpc_core::Timestamp::InfPast();
 };
 
-// EXPERIMENTAL: provide protection against overloading a server with too many
-// requests: wait for streams to be deallocated before they stop counting
-// against MAX_CONCURRENT_STREAMS
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
-  "grpc.http.overload_protection"
-
-// EXPERIMENTAL: Fail requests at the client if the client is over max
-// concurrent streams, so they may be retried elsewhere.
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT \
-  "grpc.http.max_concurrent_streams_reject_on_client"
-
 /// Transport writing call flow:
 /// grpc_chttp2_initiate_write() is called anywhere that we know bytes need to
 /// go out on the wire.

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

@@ -22,13 +22,13 @@
 #include <cstdint>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/call/message.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -53,7 +53,7 @@ class GrpcMessageAssembler {
   // This function will move the payload into an internal buffer.
   Http2Status AppendNewDataFrame(SliceBuffer& payload,
                                  const bool is_end_stream) {
-    DCHECK(!is_end_stream_)
+    GRPC_DCHECK(!is_end_stream_)
         << "Calling this function when a previous frame was marked as the last "
            "frame does not make sense.";
     is_end_stream_ = is_end_stream;
@@ -66,7 +66,7 @@ class GrpcMessageAssembler {
       }
     }
     payload.MoveFirstNBytesIntoSliceBuffer(payload.Length(), message_buffer_);
-    DCHECK_EQ(payload.Length(), 0u);
+    GRPC_DCHECK_EQ(payload.Length(), 0u);
     return Http2Status::Ok();
   }
 
@@ -135,14 +135,14 @@ class GrpcMessageDisassembler {
 
   // GrpcMessageDisassembler object will take ownership of the message.
   void PrepareSingleMessageForSending(MessageHandle message) {
-    DCHECK_EQ(GetBufferedLength(), 0u);
+    GRPC_DCHECK_EQ(GetBufferedLength(), 0u);
     PrepareMessageForSending(std::move(message));
   }
 
   // GrpcMessageDisassembler object will take ownership of the message.
   void PrepareBatchedMessageForSending(MessageHandle message) {
     PrepareMessageForSending(std::move(message));
-    DCHECK_LE(GetBufferedLength(), kMaxMessageBatchSize)
+    GRPC_DCHECK_LE(GetBufferedLength(), kMaxMessageBatchSize)
         << "Avoid batches larger than " << kMaxMessageBatchSize << "bytes";
   }
 
@@ -152,8 +152,8 @@ class GrpcMessageDisassembler {
   Http2DataFrame GenerateNextFrame(const uint32_t stream_id,
                                    const uint32_t max_length,
                                    const bool is_end_stream = false) {
-    DCHECK_GT(max_length, 0u);
-    DCHECK_GT(GetBufferedLength(), 0u);
+    GRPC_DCHECK_GT(max_length, 0u);
+    GRPC_DCHECK_GT(GetBufferedLength(), 0u);
     SliceBuffer temp;
     const uint32_t current_length =
         message_.Length() >= max_length ? max_length : message_.Length();

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

@@ -33,7 +33,6 @@
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
@@ -73,6 +72,7 @@
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/random_early_detection.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
@@ -274,7 +274,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_0:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_1;
@@ -282,7 +282,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_1:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_2;
@@ -290,7 +290,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_2:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_size |= *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_3;
@@ -298,7 +298,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_3:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_type = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_4;
@@ -306,7 +306,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_4:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_frame_flags = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_5;
@@ -314,7 +314,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_5:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_6;
@@ -322,7 +322,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_6:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_7;
@@ -330,7 +330,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_7:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_8;
@@ -338,7 +338,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FH_8:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       GRPC_TRACE_LOG(http, INFO)
           << "INCOMING[" << t << "]: "
@@ -372,7 +372,7 @@ std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       [[fallthrough]];
     case GRPC_DTS_FRAME:
-      DCHECK_LT(cur, end);
+      GRPC_DCHECK_LT(cur, end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
         err = parse_frame_slice(
             t,
@@ -671,10 +671,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                         nullptr, &t->http2_ztrace_collector));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
-    } else if (GPR_UNLIKELY(t->memory_owner.IsMemoryPressureHigh())) {
+    } else if (GPR_UNLIKELY(
+                   t->memory_owner.RejectNewStreamsUnderHighMemoryPressure())) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
-      grpc_core::global_stats().IncrementRqCallsRejected();
+      t->memory_owner.telemetry_storage()->Increment(
+          grpc_core::ResourceQuotaDomain::kCallsRejected);
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
           &t->qbuf, grpc_chttp2_rst_stream_create(
@@ -766,7 +768,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   } else {
     t->incoming_stream = s;
   }
-  DCHECK_NE(s, nullptr);
+  GRPC_DCHECK_NE(s, nullptr);
   s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   if (GPR_UNLIKELY(s->read_closed)) {
     GRPC_CHTTP2_IF_TRACING(ERROR)
@@ -976,7 +978,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   const grpc_slice& slice,
                                                   int is_last) {
   auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
-  grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
+  grpc_core::CallSpan* call_tracer = nullptr;
   if (s != nullptr) {
     s->call_tracer_wrapper.RecordIncomingBytes(
         {0, 0, GRPC_SLICE_LENGTH(slice)});

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

@@ -18,9 +18,9 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -93,7 +93,7 @@ std::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
     Duration ping_timeout,
     grpc_event_engine::experimental::EventEngine* event_engine,
     Callback callback) {
-  CHECK(started_new_ping_without_setting_timeout_);
+  GRPC_CHECK(started_new_ping_without_setting_timeout_);
   started_new_ping_without_setting_timeout_ = false;
   auto it = inflight_.find(most_recent_inflight_);
   if (it == inflight_.end()) return std::nullopt;