grpc 1.75.0 → 1.78.1

data/src/core/lib/channel/promise_based_filter.h

@@ -33,13 +33,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/container/inlined_vector.h"
-#include "absl/functional/function_ref.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/call_filters.h"
 #include "src/core/call/call_finalization.h"
 #include "src/core/call/message.h"
@@ -73,8 +66,15 @@
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/time.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/functional/function_ref.h"
+#include "absl/log/log.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -287,7 +287,7 @@ auto MapResult(const NoInterceptor*, Promise x, void*) {
 template <typename Promise, typename Derived>
 auto MapResult(absl::Status (Derived::Call::*fn)(ServerMetadata&), Promise x,
                FilterCallData<Derived>* call_data) {
-  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
+  GRPC_DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return OnCancel(Map(std::move(x),
                       [call_data](ServerMetadataHandle md) {
                         auto status =
@@ -308,7 +308,7 @@ auto MapResult(absl::Status (Derived::Call::*fn)(ServerMetadata&), Promise x,
 template <typename Promise, typename Derived>
 auto MapResult(void (Derived::Call::*fn)(ServerMetadata&), Promise x,
                FilterCallData<Derived>* call_data) {
-  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
+  GRPC_DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return OnCancel(Map(std::move(x),
                       [call_data](ServerMetadataHandle md) {
                         call_data->call.OnServerTrailingMetadata(*md);
@@ -325,7 +325,7 @@ auto MapResult(void (Derived::Call::*fn)(ServerMetadata&), Promise x,
 template <typename Promise, typename Derived>
 auto MapResult(void (Derived::Call::*fn)(ServerMetadata&, Derived*), Promise x,
                FilterCallData<Derived>* call_data) {
-  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
+  GRPC_DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return OnCancel(
       Map(std::move(x),
           [call_data](ServerMetadataHandle md) {
@@ -346,7 +346,7 @@ template <typename P, typename Call, typename Derived,
           typename = std::enable_if_t<IsFusedFilter<Derived>::value>>
 auto MapResult(void (Call::*fn)(ServerMetadata&, Derived*), P x,
                FilterCallData<Derived>* call_data) {
-  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
+  GRPC_DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return OnCancel(
       Map(std::move(x),
           [call_data](ServerMetadataHandle md) {
@@ -367,7 +367,7 @@ template <typename P, typename Call, typename Derived,
           typename = std::enable_if_t<IsFusedFilter<Derived>::value>>
 auto MapResult(void (Call::*fn)(ServerMetadata&), P x,
                FilterCallData<Derived>* call_data) {
-  DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
+  GRPC_DCHECK(fn == &Derived::Call::OnServerTrailingMetadata);
   return OnCancel(Map(std::move(x),
                       [call_data](ServerMetadataHandle md) {
                         call_data->call.OnServerTrailingMetadata(*md);
@@ -552,7 +552,7 @@ template <typename Interceptor, typename Derived>
 auto RunCall(Interceptor interceptor, CallArgs call_args,
              NextPromiseFactory next_promise_factory,
              FilterCallData<Derived>* call_data) {
-  DCHECK(interceptor == &Derived::Call::OnClientInitialMetadata);
+  GRPC_DCHECK(interceptor == &Derived::Call::OnClientInitialMetadata);
   return RunCallImpl<Interceptor, Derived>::Run(
       std::move(call_args), std::move(next_promise_factory), call_data);
 }
@@ -1248,7 +1248,9 @@ class InvalidChannelFilter : public ChannelFilter {
 };
 
 // Call data shared between all implementations of promise-based filters.
-class BaseCallData : public Activity, private Wakeable {
+class BaseCallData : public Activity,
+                     private Wakeable,
+                     public channelz::DataSource {
  protected:
   // Hook to allow interception of messages on the send/receive path by
   // PipeSender and PipeReceiver, as appropriate according to whether we're
@@ -1273,7 +1275,8 @@ class BaseCallData : public Activity, private Wakeable {
   ~BaseCallData() override;
 
   void set_pollent(grpc_polling_entity* pollent) {
-    CHECK(nullptr == pollent_.exchange(pollent, std::memory_order_release));
+    GRPC_CHECK(nullptr ==
+               pollent_.exchange(pollent, std::memory_order_release));
   }
 
   // Activity implementation (partial).
@@ -1292,6 +1295,8 @@ class BaseCallData : public Activity, private Wakeable {
 
   Call* call() { return arena_->GetContext<Call>(); }
 
+  void AddData(channelz::DataSink sink) final;
+
  protected:
   class ScopedContext : public promise_detail::Context<Arena>,
                         public promise_detail::Context<grpc_polling_entity>,
@@ -1314,7 +1319,7 @@ class BaseCallData : public Activity, private Wakeable {
     ~Flusher();
 
     void Resume(grpc_transport_stream_op_batch* batch) {
-      CHECK(!call_->is_last());
+      GRPC_CHECK(!call_->is_last());
       if (batch->HasOp()) {
         release_.push_back(batch);
       } else if (batch->on_complete != nullptr) {
@@ -1393,7 +1398,7 @@ class BaseCallData : public Activity, private Wakeable {
     PipeSender<MessageHandle>* original_sender() override { abort(); }
 
     void GotPipe(PipeReceiver<MessageHandle>* receiver) override {
-      CHECK_EQ(receiver_, nullptr);
+      GRPC_CHECK_EQ(receiver_, nullptr);
       receiver_ = receiver;
     }
 
@@ -1401,7 +1406,7 @@ class BaseCallData : public Activity, private Wakeable {
 
     PipeSender<MessageHandle>* Push() override { return &pipe_.sender; }
     PipeReceiver<MessageHandle>* Pull() override {
-      CHECK_NE(receiver_, nullptr);
+      GRPC_CHECK_NE(receiver_, nullptr);
       return receiver_;
     }
 
@@ -1422,12 +1427,12 @@ class BaseCallData : public Activity, private Wakeable {
     void GotPipe(PipeReceiver<MessageHandle>*) override { abort(); }
 
     void GotPipe(PipeSender<MessageHandle>* sender) override {
-      CHECK_EQ(sender_, nullptr);
+      GRPC_CHECK_EQ(sender_, nullptr);
       sender_ = sender;
     }
 
     PipeSender<MessageHandle>* Push() override {
-      CHECK_NE(sender_, nullptr);
+      GRPC_CHECK_NE(sender_, nullptr);
       return sender_;
     }
     PipeReceiver<MessageHandle>* Pull() override { return &pipe_.receiver; }
@@ -1470,6 +1475,10 @@ class BaseCallData : public Activity, private Wakeable {
     // Return true if we've released the message for forwarding down the stack.
     bool IsForwarded() const { return state_ == State::kForwardedBatch; }
 
+    channelz::PropertyList ChannelzProperties() {
+      return channelz::PropertyList().Set("state", StateString(state_));
+    }
+
    private:
     enum class State : uint8_t {
       // Starting state: no batch started, no outgoing pipe configured.
@@ -1543,6 +1552,10 @@ class BaseCallData : public Activity, private Wakeable {
     // Call is completed, we have trailing metadata. Close things out.
     void Done(const ServerMetadata& metadata, Flusher* flusher);
 
+    channelz::PropertyList ChannelzProperties() {
+      return channelz::PropertyList().Set("state", StateString(state_));
+    }
+
    private:
     enum class State : uint8_t {
       // Starting state: no batch started, no incoming pipe configured.
@@ -1625,6 +1638,7 @@ class BaseCallData : public Activity, private Wakeable {
   }
   SendMessage* send_message() const { return send_message_; }
   ReceiveMessage* receive_message() const { return receive_message_; }
+  virtual channelz::PropertyList ChannelzProperties() const;
 
   bool is_last() const {
     return grpc_call_stack_element(call_stack_, call_stack_->count - 1) ==
@@ -1706,6 +1720,7 @@ class ClientCallData : public BaseCallData {
   static const char* StateString(SendInitialState);
   static const char* StateString(RecvTrailingState);
   std::string DebugString() const;
+  channelz::PropertyList ChannelzProperties() const override;
 
   struct RecvInitialMetadata;
   class PollContext;
@@ -1822,6 +1837,7 @@ class ServerCallData : public BaseCallData {
   static const char* StateString(RecvInitialState state);
   static const char* StateString(SendTrailingState state);
   std::string DebugString() const;
+  channelz::PropertyList ChannelzProperties() const override;
 
   class PollContext;
   struct SendInitialMetadata;
@@ -1942,7 +1958,7 @@ struct CallDataFilterWithFlagsMethods {
     if ((kFlags & kFilterIsLast) != 0) {
       ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, absl::OkStatus());
     } else {
-      CHECK_EQ(then_schedule_closure, nullptr);
+      GRPC_CHECK_EQ(then_schedule_closure, nullptr);
     }
   }
 };
@@ -1979,12 +1995,12 @@ template <typename F, uint8_t kFlags>
 struct ChannelFilterWithFlagsMethods {
   static absl::Status InitChannelElem(grpc_channel_element* elem,
                                       grpc_channel_element_args* args) {
-    CHECK(args->is_last == ((kFlags & kFilterIsLast) != 0));
+    GRPC_CHECK(args->is_last == ((kFlags & kFilterIsLast) != 0));
     auto status =
         F::Create(args->channel_args,
                   ChannelFilter::Args(args->channel_stack, elem,
                                       grpc_channel_stack_filter_instance_number,
-                                      args->blackboard));
+                                      args->config, args->blackboard));
     if (!status.ok()) {
       new (elem->channel_data) F*(nullptr);
       return absl_status_to_grpc_error(status.status());

data/src/core/lib/compression/compression_internal.cc

@@ -24,16 +24,16 @@
 
 #include <string>
 
-#include "absl/container/inlined_vector.h"
-#include "absl/log/check.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_split.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/ref_counted_string.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_split.h"
 
 namespace grpc_core {
 
@@ -118,7 +118,7 @@ CompressionAlgorithmSet::CompressionAlgorithmForLevel(
     return GRPC_COMPRESS_NONE;
   }
 
-  CHECK_GT(level, 0);
+  GRPC_CHECK_GT(level, 0);
 
   // Establish a "ranking" or compression algorithms in increasing order of
   // compression.

data/src/core/lib/compression/compression_internal.h

@@ -26,10 +26,10 @@
 #include <initializer_list>
 #include <optional>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/bitset.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/lib/compression/message_compress.cc

@@ -25,9 +25,9 @@
 #include <zconf.h>
 #include <zlib.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 #define OUTPUT_BLOCK_SIZE 1024
 
@@ -40,20 +40,20 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
   const uInt uint_max = ~uInt{0};
 
-  CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
+  GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
   zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
   zs->next_out = GRPC_SLICE_START_PTR(outbuf);
   flush = Z_NO_FLUSH;
   for (i = 0; i < input->count; i++) {
     if (i == input->count - 1) flush = Z_FINISH;
-    CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
+    GRPC_CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
     zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
     zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
     do {
       if (zs->avail_out == 0) {
         grpc_slice_buffer_add_indexed(output, outbuf);
         outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-        CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
+        GRPC_CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
         zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
         zs->next_out = GRPC_SLICE_START_PTR(outbuf);
       }
@@ -73,7 +73,7 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
     goto error;
   }
 
-  CHECK(outbuf.refcount);
+  GRPC_CHECK(outbuf.refcount);
   outbuf.data.refcounted.length -= zs->avail_out;
   grpc_slice_buffer_add_indexed(output, outbuf);
 
@@ -103,7 +103,7 @@ static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   zs.zfree = zfree_gpr;
   r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
                    8, Z_DEFAULT_STRATEGY);
-  CHECK(r == Z_OK);
+  GRPC_CHECK(r == Z_OK);
   r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
   if (!r) {
     for (i = count_before; i < output->count; i++) {
@@ -127,7 +127,7 @@ static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   zs.zalloc = zalloc_gpr;
   zs.zfree = zfree_gpr;
   r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
-  CHECK(r == Z_OK);
+  GRPC_CHECK(r == Z_OK);
   r = zlib_body(&zs, input, output, inflate);
   if (!r) {
     for (i = count_before; i < output->count; i++) {

data/src/core/lib/debug/trace.cc

@@ -18,23 +18,20 @@
 
 #include "src/core/lib/debug/trace.h"
 
-#include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
 #include <string>
 #include <type_traits>
 #include <utility>
 
+#include "src/core/config/config_vars.h"
+#include "src/core/util/glob.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "src/core/config/config_vars.h"
-#include "src/core/util/glob.h"
-
-int grpc_tracer_set_enabled(const char* name, int enabled);
 
 namespace grpc_core {
 namespace {

data/src/core/lib/debug/trace.h

@@ -18,4 +18,14 @@
 #include "src/core/lib/debug/trace_flags.h"  // IWYU pragma: export
 #include "src/core/lib/debug/trace_impl.h"   // IWYU pragma: export
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int grpc_tracer_set_enabled(const char* name, int enabled);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_H

data/src/core/lib/debug/trace_flags.cc

@@ -13,12 +13,12 @@
 // limitations under the License.
 
 //
-// Automatically generated by tools/codegen/core/gen_trace_flags.py
+// Automatically generated by tools/codegen/core/generate_trace_flags.cc
 //
 
-#include "absl/container/flat_hash_map.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/no_destruct.h"
+#include "absl/container/flat_hash_map.h"
 
 namespace grpc_core {
 

data/src/core/lib/debug/trace_flags.h

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 //
-// Automatically generated by tools/codegen/core/gen_trace_flags.py
+// Automatically generated by tools/codegen/core/generate_trace_flags.cc
 //
 
 #ifndef GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H

data/src/core/lib/event_engine/ares_resolver.cc

@@ -53,15 +53,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/match.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/substitute.h"
 #include "src/core/config/config_vars.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -70,9 +61,18 @@
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
 #ifdef GRPC_POSIX_SOCKET_ARES_EV_DRIVER
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif
@@ -280,9 +280,9 @@ AresResolver::AresResolver(
 }
 
 AresResolver::~AresResolver() {
-  CHECK(fd_node_list_.empty());
-  CHECK(callback_map_.empty());
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK(fd_node_list_.empty());
+  GRPC_CHECK(callback_map_.empty());
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
 }
 
@@ -367,7 +367,7 @@ void AresResolver::LookupHostname(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   if (AresIsIpv6LoopbackAvailable()) {
     // Note that using AF_UNSPEC for both IPv6 and IPv4 queries does not work in
     // all cases, e.g. for localhost:<> it only gets back the IPv6 result (i.e.
@@ -415,7 +415,7 @@ void AresResolver::LookupSRV(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_query(channel_, std::string(host).c_str(), ns_c_in, ns_t_srv,
              &AresResolver::OnSRVQueryDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -451,7 +451,7 @@ void AresResolver::LookupTXT(
   grpc_core::MutexLock lock(&mutex_);
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new QueryArg(this, id_, host);
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_search(channel_, std::string(host).c_str(), ns_c_in, ns_t_txt,
               &AresResolver::OnTXTDoneLocked, resolver_arg);
   CheckSocketsLocked();
@@ -576,7 +576,7 @@ void AresResolver::MaybeStartTimerLocked() {
 
 void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  CHECK(fd_node->readable_registered);
+  GRPC_CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
@@ -598,7 +598,7 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
 
 void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  CHECK(fd_node->writable_registered);
+  GRPC_CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
   GRPC_TRACE_LOG(cares_resolver, INFO)
       << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
@@ -650,7 +650,7 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
                                           int /*timeouts*/,
                                           struct hostent* hostent) {
   auto* hostname_qa = static_cast<HostnameQueryArg*>(arg);
-  CHECK_GT(hostname_qa->pending_requests--, 0);
+  GRPC_CHECK_GT(hostname_qa->pending_requests--, 0);
   auto* ares_resolver = hostname_qa->ares_resolver;
   if (status != ARES_SUCCESS) {
     std::string error_msg =
@@ -722,8 +722,8 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
       delete hostname_qa;
       return;
     }
-    CHECK(std::holds_alternative<
-          EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
+    GRPC_CHECK(std::holds_alternative<
+               EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = std::get<EventEngine::DNSResolver::LookupHostnameCallback>(
         std::move(nh.mapped()));
     if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
@@ -751,8 +751,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   if (nh.empty()) {
     return;
   }
-  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
-      nh.mapped()));
+  GRPC_CHECK(
+      std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
+          nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupSRVCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -814,8 +815,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   if (nh.empty()) {
     return;
   }
-  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
-      nh.mapped()));
+  GRPC_CHECK(
+      std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
+          nh.mapped()));
   auto callback = std::get<EventEngine::DNSResolver::LookupTXTCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -894,7 +896,7 @@ void AresResolver::Reset(const absl::Status& reason) {
   callback_map_.clear();
   ShutdownLocked(reason, "resolver reset");
   CheckSocketsLocked();
-  CHECK_NE(channel_, nullptr);
+  GRPC_CHECK_NE(channel_, nullptr);
   ares_destroy(channel_);
   channel_ = nullptr;
 }
@@ -903,10 +905,10 @@ void AresResolver::Restart() {
   grpc_core::MutexLock lock(&mutex_);
   polled_fd_factory_ = polled_fd_factory_->NewEmptyInstance();
   polled_fd_factory_->Initialize(&mutex_, event_engine_.get());
-  CHECK_EQ(channel_, nullptr);
+  GRPC_CHECK_EQ(channel_, nullptr);
   absl::Status status =
       InitAresChannel(dns_server_, *polled_fd_factory_, &channel_);
-  CHECK_OK(status);
+  GRPC_CHECK_OK(status);
 }
 
 #endif  // GRPC_ENABLE_FORK_SUPPORT
@@ -922,7 +924,7 @@ void AresResolver::ShutdownLocked(const absl::Status& shutdown_status,
       GRPC_TRACE_LOG(cares_resolver, INFO) << absl::Substitute(
           "(EventEngine c-ares resolver) resolver: $0 shutdown fd: $1 ($2)",
           this, fd_node->polled_fd->GetName(), reason);
-      CHECK(fd_node->polled_fd->ShutdownLocked(shutdown_status));
+      GRPC_CHECK(fd_node->polled_fd->ShutdownLocked(shutdown_status));
       fd_node->already_shutdown = true;
     }
   }

data/src/core/lib/event_engine/ares_resolver.h

@@ -30,14 +30,14 @@
 #include <list>
 #include <memory>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/cf_engine/cf_engine.cc

@@ -21,8 +21,6 @@
 #include <CoreFoundation/CoreFoundation.h>
 #include <grpc/support/cpu.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 #include "src/core/lib/event_engine/cf_engine/cfsocket_listener.h"
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
@@ -32,7 +30,9 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
 
 #ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
 #define GRPC_CFSTREAM_MAX_THREADPOOL_SIZE 16u
@@ -74,7 +74,7 @@ CFEventEngine::~CFEventEngine() {
                    << HandleToString(handle);
       }
     }
-    CHECK(GPR_LIKELY(known_handles_.empty()));
+    GRPC_CHECK(GPR_LIKELY(known_handles_.empty()));
     timer_manager_.Shutdown();
   }
   thread_pool_->Quiesce();

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -18,11 +18,11 @@
 #include <AvailabilityMacros.h>
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
+#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
+#include "src/core/util/strerror.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
-#include "src/core/util/strerror.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.h

@@ -22,7 +22,6 @@
 #include <CoreFoundation/CoreFoundation.h>
 #include <grpc/event_engine/event_engine.h>
 
-#include "absl/strings/str_format.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 #include "src/core/lib/event_engine/cf_engine/cftype_unique_ref.h"
@@ -31,6 +30,7 @@
 #include "src/core/util/host_port.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -18,14 +18,14 @@
 #include <AvailabilityMacros.h>
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
-#include "absl/log/check.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -148,7 +148,7 @@ void DNSServiceResolverImpl::ResolveCallback(
 
   grpc_core::ReleasableMutexLock lock(&that->request_mu_);
   auto request_it = that->requests_.find(sdRef);
-  CHECK(request_it != that->requests_.end());
+  GRPC_CHECK(request_it != that->requests_.end());
 
   if (errorCode != kDNSServiceErr_NoError &&
       errorCode != kDNSServiceErr_NoSuchRecord) {