grpc 1.75.0 → 1.78.0

data/src/core/lib/promise/party.cc

@@ -20,21 +20,22 @@
 #include <cstdint>
 #include <limits>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_format.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_format.h"
 
 #ifdef GRPC_MAXIMIZE_THREADYNESS
-#include "absl/random/random.h"           // IWYU pragma: keep
 #include "src/core/lib/iomgr/exec_ctx.h"  // IWYU pragma: keep
 #include "src/core/util/thd.h"            // IWYU pragma: keep
+#include "absl/random/random.h"           // IWYU pragma: keep
 #endif
 
 namespace grpc_core {
@@ -73,7 +74,7 @@ class Party::Handle final : public Wakeable {
   // Activity is going away... drop its reference and sever the connection back.
   void DropActivity() ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
-    CHECK_NE(party_, nullptr);
+    GRPC_CHECK_NE(party_, nullptr);
     party_ = nullptr;
     mu_.Unlock();
     Unref();
@@ -201,14 +202,24 @@ void Party::ToJson(absl::AnyInvocable<void(Json::Object)> f) {
       [](absl::Status) {});
 }
 
-void Party::ExportToChannelz(std::string name, channelz::DataSink sink) {
-  Spawn(
-      "export-to-channelz",
-      [name = std::move(name), sink = std::move(sink), self = Ref()]() mutable {
-        sink.AddData(std::move(name), self->ChannelzPropertiesLocked());
-        return absl::OkStatus();
-      },
-      [](absl::Status) {});
+void Party::ExportToChannelz(
+    std::string name, channelz::DataSink sink,
+    absl::AnyInvocable<channelz::PropertyList()> export_context) {
+  arena()->GetContext<grpc_event_engine::experimental::EventEngine>()->Run(
+      [self = Ref(), name = std::move(name), sink = std::move(sink),
+       export_context = std::move(export_context)]() mutable {
+        ExecCtx exec_ctx;
+        self->Spawn(
+            "export-to-channelz",
+            [name = std::move(name), sink = std::move(sink), self,
+             export_context = std::move(export_context)]() mutable {
+              sink.AddData(
+                  std::move(name),
+                  self->ChannelzPropertiesLocked().Merge(export_context()));
+              return absl::OkStatus();
+            },
+            [](absl::Status) {});
+      });
 }
 
 channelz::PropertyList Party::ChannelzPropertiesLocked() {
@@ -226,7 +237,8 @@ channelz::PropertyList Party::ChannelzPropertiesLocked() {
         for (size_t i = 0; i < party_detail::kMaxParticipants; i++) {
           if (auto* p = participants_[i].load(std::memory_order_acquire);
               p != nullptr) {
-            table.AppendRow(p->ChannelzProperties());
+            table.AppendRow(channelz::PropertyList().Set(
+                "participant", p->ChannelzProperties()));
           }
         }
         return table;
@@ -259,13 +271,13 @@ std::string Party::ActivityDebugTag(WakeupMask wakeup_mask) const {
 }
 
 Waker Party::MakeOwningWaker() {
-  DCHECK(currently_polling_ != kNotPolling);
+  GRPC_DCHECK(currently_polling_ != kNotPolling);
   IncrementRefCount();
   return Waker(this, 1u << currently_polling_);
 }
 
 Waker Party::MakeNonOwningWaker() {
-  DCHECK(currently_polling_ != kNotPolling);
+  GRPC_DCHECK(currently_polling_ != kNotPolling);
   return Waker(participants_[currently_polling_]
                    .load(std::memory_order_relaxed)
                    ->MakeNonOwningWakeable(this),
@@ -273,7 +285,7 @@ Waker Party::MakeNonOwningWaker() {
 }
 
 void Party::ForceImmediateRepoll(WakeupMask mask) {
-  DCHECK(is_current());
+  GRPC_DCHECK(is_current());
   wakeup_mask_ |= mask;
 }
 
@@ -306,11 +318,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       g_run_state = this;
       do {
         GRPC_LATENT_SEE_SCOPE("run_one_party");
-        CHECK(first.party != nullptr);
+        GRPC_CHECK(first.party != nullptr);
         first.party->RunPartyAndUnref(first.prev_state);
         first = std::exchange(next, PartyWakeup{});
       } while (first.party != nullptr);
-      DCHECK(g_run_state == this);
+      GRPC_DCHECK(g_run_state == this);
       g_run_state = nullptr;
     }
   };
@@ -338,10 +350,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       auto wakeup =
           std::exchange(g_run_state->next, PartyWakeup{party, prev_state});
       auto arena = wakeup.party->arena_.get();
-      CHECK(arena != nullptr);
+      GRPC_CHECK(arena != nullptr);
       auto* event_engine =
           arena->GetContext<grpc_event_engine::experimental::EventEngine>();
-      CHECK(event_engine != nullptr) << "; " << GRPC_DUMP_ARGS(party, arena);
+      GRPC_CHECK(event_engine != nullptr)
+          << "; " << GRPC_DUMP_ARGS(party, arena);
       GRPC_LATENT_SEE_SCOPE("offload_one_party");
       event_engine->Run([wakeup]() {
         GRPC_LATENT_SEE_SCOPE("Party::RunLocked offload");
@@ -360,11 +373,11 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
 void Party::RunPartyAndUnref(uint64_t prev_state) {
   ScopedActivity activity(this);
   promise_detail::Context<Arena> arena_ctx(arena_.get());
-  DCHECK_EQ(prev_state & kLocked, 0u)
+  GRPC_DCHECK_EQ(prev_state & kLocked, 0u)
       << "Party should be unlocked prior to first wakeup";
-  DCHECK_GE(prev_state & kRefMask, kOneRef);
+  GRPC_DCHECK_GE(prev_state & kRefMask, kOneRef);
   // Now update prev_state to be what we want the CAS to see below.
-  DCHECK_EQ(prev_state & ~(kRefMask | kAllocatedMask), 0u)
+  GRPC_DCHECK_EQ(prev_state & ~(kRefMask | kAllocatedMask), 0u)
       << "Party should have contained no wakeups on lock";
   prev_state |= kLocked;
 #if !TARGET_OS_IPHONE
@@ -432,9 +445,9 @@ void Party::RunPartyAndUnref(uint64_t prev_state) {
     }
     LogStateChange("Run:Continue", prev_state,
                    prev_state & (kRefMask | kLocked | keep_allocated_mask));
-    DCHECK(prev_state & kLocked)
+    GRPC_DCHECK(prev_state & kLocked)
         << "Party should be locked; prev_state=" << prev_state;
-    DCHECK_GE(prev_state & kRefMask, kOneRef);
+    GRPC_DCHECK_GE(prev_state & kRefMask, kOneRef);
     // From the previous state, extract which participants we're to wakeup.
     wakeup_mask_ |= prev_state & kWakeupMask;
     // Now update prev_state to be what we want the CAS to see once wakeups
@@ -457,7 +470,7 @@ uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
 }
 #else
 uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
-  CHECK_EQ(current_allocation_mask & ~kWakeupMask, 0);
+  GRPC_CHECK_EQ(current_allocation_mask & ~kWakeupMask, 0);
   if (current_allocation_mask == kWakeupMask) return kWakeupMask + 1;
   // Count number of unset bits in the wakeup mask
   size_t unset_bits = 0;
@@ -465,7 +478,7 @@ uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
     if (current_allocation_mask & (1ull << i)) continue;
     ++unset_bits;
   }
-  CHECK_GT(unset_bits, 0);
+  GRPC_CHECK_GT(unset_bits, 0);
   absl::BitGen bitgen;
   size_t selected = absl::Uniform<size_t>(bitgen, 0, unset_bits);
   for (size_t i = 0; i < party_detail::kMaxParticipants; i++) {
@@ -494,7 +507,7 @@ size_t Party::AddParticipant(Participant* participant) {
     if (GPR_UNLIKELY((wakeup_mask & kWakeupMask) == 0)) {
       return std::numeric_limits<size_t>::max();
     }
-    DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
+    GRPC_DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "No available slots for new participant; allocated=" << allocated
         << " state=" << state << " wakeup_mask=" << wakeup_mask;
     allocated |= wakeup_mask;

data/src/core/lib/promise/party.h

@@ -25,10 +25,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/attributes.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
@@ -41,9 +37,13 @@
 #include "src/core/util/check_class_size.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/base/attributes.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -211,7 +211,7 @@ class Party : public Activity, private Wakeable {
           party->state_.compare_exchange_weak(prev_state_,
                                               (prev_state_ | kLocked) + kOneRef,
                                               std::memory_order_relaxed)) {
-        DCHECK_EQ(prev_state_ & ~(kRefMask | kAllocatedMask), 0u)
+        GRPC_DCHECK_EQ(prev_state_ & ~(kRefMask | kAllocatedMask), 0u)
             << "Party should have contained no wakeups on lock";
         // If we win, record that fact for the destructor
         party->LogStateChange("WakeupHold", prev_state_,
@@ -349,7 +349,7 @@ class Party : public Activity, private Wakeable {
   // Activity implementation: not allowed to be overridden by derived types.
   void ForceImmediateRepoll(WakeupMask mask) final;
   WakeupMask CurrentParticipant() const final {
-    DCHECK(currently_polling_ != kNotPolling);
+    GRPC_DCHECK(currently_polling_ != kNotPolling);
     return 1u << currently_polling_;
   }
   Waker MakeOwningWaker() final;
@@ -383,7 +383,7 @@ class Party : public Activity, private Wakeable {
   SpawnSerializer* MakeSpawnSerializer() {
     auto* const serializer = arena_->New<SpawnSerializer>(this);
     const size_t slot = AddParticipant(serializer);
-    DCHECK_NE(slot, std::numeric_limits<size_t>::max());
+    GRPC_DCHECK_NE(slot, std::numeric_limits<size_t>::max());
     serializer->wakeup_mask_ = 1ull << slot;
     return serializer;
   }
@@ -394,15 +394,23 @@ class Party : public Activity, private Wakeable {
   void ToJson(absl::AnyInvocable<void(Json::Object)>);
 
   // Export the party to channelz.
-  void ExportToChannelz(std::string name, channelz::DataSink sink);
+  // The final argument is called whilst the party is locked, and so can be used
+  // to export contextual data alongside the party.
+  void ExportToChannelz(
+      std::string name, channelz::DataSink sink,
+      absl::AnyInvocable<channelz::PropertyList()> export_context = []() {
+        // The default implementation does nothing.
+        return channelz::PropertyList();
+      });
 
  protected:
   friend class Arena;
 
   // Derived types should be constructed upon `arena`.
   explicit Party(RefCountedPtr<Arena> arena) : arena_(std::move(arena)) {
-    CHECK(arena_->GetContext<grpc_event_engine::experimental::EventEngine>() !=
-          nullptr);
+    GRPC_CHECK(
+        arena_->GetContext<grpc_event_engine::experimental::EventEngine>() !=
+        nullptr);
   }
   ~Party() override;
 
@@ -455,15 +463,11 @@ class Party : public Activity, private Wakeable {
     channelz::PropertyList ChannelzProperties() override {
       return channelz::PropertyList()
           .Set("on_complete", TypeName<OnComplete>())
-          .Set("factory", [this]() {
-            channelz::PropertyList factory;
-            if (started_) {
-              factory.Set("promise", PromiseProperty(&promise_));
-            } else {
-              factory.Set("factory",
-                          TypeName<typename Factory::UnderlyingFactory>());
-            }
-            return factory;
+          .Set("factory", TypeName<typename Factory::UnderlyingFactory>())
+          .Merge([this]() {
+            channelz::PropertyList p;
+            if (started_) p.Set("promise", PromiseProperty(&promise_));
+            return p;
           }());
     }
 
@@ -636,7 +640,7 @@ class Party : public Activity, private Wakeable {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void WakeupFromState(
       uint64_t cur_state, WakeupMask wakeup_mask) {
     GRPC_LATENT_SEE_SCOPE("Party::WakeupFromState");
-    DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
+    GRPC_DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "Wakeup mask must be non-zero: " << wakeup_mask;
     while (true) {
       if (cur_state & kLocked) {
@@ -644,9 +648,9 @@ class Party : public Activity, private Wakeable {
         // we'll immediately unref. Since something is running this should never
         // bring the refcount to zero.
         if constexpr (kReffed) {
-          DCHECK_GT(cur_state & kRefMask, kOneRef);
+          GRPC_DCHECK_GT(cur_state & kRefMask, kOneRef);
         } else {
-          DCHECK_GE(cur_state & kRefMask, kOneRef);
+          GRPC_DCHECK_GE(cur_state & kRefMask, kOneRef);
         }
         const uint64_t new_state =
             (cur_state | wakeup_mask) - (kReffed ? kOneRef : 0);
@@ -657,7 +661,7 @@ class Party : public Activity, private Wakeable {
         }
       } else {
         // If the party is not locked, we need to lock it and run.
-        DCHECK_EQ(cur_state & kWakeupMask, 0u);
+        GRPC_DCHECK_EQ(cur_state & kWakeupMask, 0u);
         const uint64_t new_state =
             (cur_state | kLocked) + (kReffed ? 0 : kOneRef);
         if (state_.compare_exchange_weak(cur_state, new_state,

data/src/core/lib/promise/pipe.h

@@ -25,9 +25,7 @@
 #include <utility>
 #include <variant>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/if.h"
@@ -37,7 +35,10 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -58,10 +59,10 @@ struct Pipe;
 template <typename T>
 class NextResult final {
  public:
-  NextResult() : center_(nullptr) {}
+  NextResult() : center_(nullptr), cancelled_(true) {}
   explicit NextResult(RefCountedPtr<pipe_detail::Center<T>> center)
-      : center_(std::move(center)) {
-    CHECK(center_ != nullptr);
+      : center_(std::move(center)), cancelled_(false) {
+    GRPC_CHECK(center_ != nullptr);
   }
   explicit NextResult(bool cancelled)
       : center_(nullptr), cancelled_(cancelled) {}
@@ -77,11 +78,11 @@ class NextResult final {
   bool has_value() const;
   // Only valid if has_value()
   const T& value() const {
-    CHECK(has_value());
+    GRPC_CHECK(has_value());
     return **this;
   }
   T& value() {
-    CHECK(has_value());
+    GRPC_CHECK(has_value());
     return **this;
   }
   const T& operator*() const;
@@ -118,7 +119,7 @@ class Center : public InterceptorList<T> {
     GRPC_TRACE_VLOG(promise_primitives, 2)
         << DebugOpString("IncrementRefCount");
     refs_++;
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
   }
 
   RefCountedPtr<Center> Ref() {
@@ -130,7 +131,7 @@ class Center : public InterceptorList<T> {
   // If no refs remain, destroy this object
   void Unref() {
     GRPC_TRACE_VLOG(promise_primitives, 2) << DebugOpString("Unref");
-    DCHECK_GT(refs_, 0);
+    GRPC_DCHECK_GT(refs_, 0);
     refs_--;
     if (0 == refs_) {
       this->~Center();
@@ -143,7 +144,7 @@ class Center : public InterceptorList<T> {
   // Return false if the recv end is closed.
   Poll<bool> Push(T* value) {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Push");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
       case ValueState::kReadyClosed:
@@ -165,7 +166,7 @@ class Center : public InterceptorList<T> {
 
   Poll<bool> PollAck() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollAck");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
         return true;
@@ -191,7 +192,7 @@ class Center : public InterceptorList<T> {
   // Return nullopt if the send end is closed and no value had been pushed.
   Poll<std::optional<T>> Next() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Next");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -216,7 +217,7 @@ class Center : public InterceptorList<T> {
   Poll<bool> PollClosedForSender() {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugOpString("PollClosedForSender");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -238,7 +239,7 @@ class Center : public InterceptorList<T> {
   Poll<bool> PollClosedForReceiver() {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugOpString("PollClosedForReceiver");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -257,7 +258,7 @@ class Center : public InterceptorList<T> {
 
   Poll<Empty> PollEmpty() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollEmpty");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kReady:
       case ValueState::kReadyClosed:
@@ -360,6 +361,15 @@ class Center : public InterceptorList<T> {
     }
   }
 
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("refs", refs_)
+        .Set("state", ValueStateName(value_state_))
+        .Set("on_empty", on_empty_.DebugString())
+        .Set("on_full", on_full_.DebugString())
+        .Set("on_closed", on_closed_.DebugString());
+  }
+
  private:
   // State of value_.
   enum class ValueState : uint8_t {
@@ -460,6 +470,10 @@ class PipeSender {
     }
   }
 
+  channelz::PropertyList ChannelzProperties() {
+    return center_->ChannelzProperties();
+  }
+
   void Swap(PipeSender<T>* other) { std::swap(center_, other->center_); }
 
   // Send a single message along the pipe.
@@ -646,7 +660,7 @@ class Push {
         return Pending{};
       }
     }
-    DCHECK(std::holds_alternative<AwaitingAck>(state_));
+    GRPC_DCHECK(std::holds_alternative<AwaitingAck>(state_));
     return center_->PollAck();
   }
 

data/src/core/lib/promise/poll.h

@@ -21,10 +21,11 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
+#include "src/core/util/construct_destruct.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
 
@@ -112,12 +113,12 @@ class Poll {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& value() {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return value_;
   }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& value() const {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return value_;
   }
 
@@ -174,7 +175,7 @@ class Poll<Empty> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty value() const {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return Empty{};
   }
 

data/src/core/lib/promise/promise.h

@@ -20,12 +20,10 @@
 #include <optional>
 #include <type_traits>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/util/function_signature.h"
-#include "src/core/util/json/json.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/sleep.cc

@@ -56,7 +56,9 @@ Poll<absl::Status> Sleep::operator()() {
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
-    : waker_(GetContext<Activity>()->MakeOwningWaker()),
+    : waker_((IsSleepUseNonOwningWakerEnabled())
+                 ? GetContext<Activity>()->MakeNonOwningWaker()
+                 : GetContext<Activity>()->MakeOwningWaker()),
       event_engine_(GetContext<EventEngine>()->shared_from_this()),
       timer_handle_(
           event_engine_->RunAfter(deadline - Timestamp::Now(), this)) {}

data/src/core/lib/promise/sleep.h

@@ -21,10 +21,10 @@
 #include <atomic>
 #include <utility>
 
-#include "absl/status/status.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/time.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 

data/src/core/lib/promise/status_flag.h

@@ -20,12 +20,12 @@
 #include <optional>
 #include <ostream>
 
-#include "absl/log/check.h"
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
-#include "src/core/lib/promise/detail/status.h"
 
 namespace grpc_core {
 
@@ -198,7 +198,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -207,7 +207,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -216,7 +216,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, const StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -230,7 +230,7 @@ class ValueOrFailure {
   // NOLINTNEXTLINE(google-explicit-constructor)
   ValueOrFailure(Failure) {}
   // NOLINTNEXTLINE(google-explicit-constructor)
-  ValueOrFailure(StatusFlag status) { CHECK(!status.ok()); }
+  ValueOrFailure(StatusFlag status) { GRPC_CHECK(!status.ok()); }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure FromOptional(
       std::optional<T> value) {
@@ -356,7 +356,7 @@ template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
       StatusFlag f) {
-    CHECK(!f.ok());
+    GRPC_CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
 };
@@ -365,7 +365,7 @@ template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
       StatusFlag f) {
-    CHECK(!f.ok());
+    GRPC_CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
 };

data/src/core/lib/promise/try_join.h

@@ -20,14 +20,14 @@
 #include <tuple>
 #include <variant>
 
-#include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/promise/detail/join_state.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 
@@ -212,7 +212,7 @@ struct TryJoinTraits {
   template <typename R, typename T>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(
       const ValueOrFailure<T>& x) {
-    CHECK(!x.ok());
+    GRPC_CHECK(!x.ok());
     return FailureStatusCast<R>(Failure{});
   }
   template <typename... A>

data/src/core/lib/promise/try_seq.h

@@ -21,16 +21,16 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/detail/seq_state.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 
@@ -208,7 +208,7 @@ struct TrySeqTraitsWithSfinae<
   }
   template <typename R>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(T&& status) {
-    DCHECK(!IsStatusOk(status));
+    GRPC_DCHECK(!IsStatusOk(status));
     return FailureStatusCast<R>(status.status());
   }
   template <typename Result, typename RunNext>