grpc 1.63.0 → 1.65.2

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

@@ -0,0 +1,182 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_OBSERVABLE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_OBSERVABLE_H
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Observable allows broadcasting a value to multiple interested observers.
+template <typename T>
+class Observable {
+ public:
+  // We need to assign a value initially.
+  explicit Observable(T initial)
+      : state_(MakeRefCounted<State>(std::move(initial))) {}
+
+  // Update the value to something new. Awakes any waiters.
+  void Set(T value) { state_->Set(std::move(value)); }
+
+  // Returns a promise that resolves to a T when is_acceptable returns true for
+  // that value.
+  // is_acceptable is any invocable that takes a `const T&` and returns a bool.
+  template <typename F>
+  auto NextWhen(F is_acceptable) {
+    return ObserverWhen<F>(state_, std::move(is_acceptable));
+  }
+
+  // Returns a promise that resolves to a T when the value becomes != current.
+  auto Next(T current) {
+    return NextWhen([current = std::move(current)](const T& value) {
+      return value != current;
+    });
+  }
+
+ private:
+  // Forward declaration so we can form pointers to Observer in State.
+  class Observer;
+
+  // State keeps track of all observable state.
+  // It's a refcounted object so that promises reading the state are not tied
+  // to the lifetime of the Observable.
+  class State : public RefCounted<State> {
+   public:
+    explicit State(T value) : value_(std::move(value)) {}
+
+    // Update the value and wake all observers.
+    void Set(T value) {
+      MutexLock lock(&mu_);
+      std::swap(value_, value);
+      WakeAll();
+    }
+
+    // Export our mutex so that Observer can use it.
+    Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
+
+    // Fetch a ref to the current value.
+    const T& current() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      return value_;
+    }
+
+    // Remove an observer from the set (it no longer needs updates).
+    void Remove(Observer* observer) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      observers_.erase(observer);
+    }
+
+    // Add an observer to the set (it needs updates).
+    GRPC_MUST_USE_RESULT Waker Add(Observer* observer)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      observers_.insert(observer);
+      return GetContext<Activity>()->MakeNonOwningWaker();
+    }
+
+   private:
+    // Wake all observers.
+    void WakeAll() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+      for (auto* observer : observers_) {
+        observer->Wakeup();
+      }
+    }
+
+    Mutex mu_;
+    // All observers that may need an update.
+    absl::flat_hash_set<Observer*> observers_ ABSL_GUARDED_BY(mu_);
+    // The current value.
+    T value_ ABSL_GUARDED_BY(mu_);
+  };
+
+  // A promise that resolves to a T when ShouldReturn() returns true.
+  // Subclasses must implement ShouldReturn().
+  class Observer {
+   public:
+    explicit Observer(RefCountedPtr<State> state) : state_(std::move(state)) {}
+
+    virtual ~Observer() {
+      // If we saw a pending at all then we *may* be in the set of observers.
+      // If not we're definitely not and we can avoid taking the lock at all.
+      if (!saw_pending_) return;
+      MutexLock lock(state_->mu());
+      auto w = std::move(waker_);
+      state_->Remove(this);
+    }
+
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
+    Observer(Observer&& other) noexcept : state_(std::move(other.state_)) {
+      CHECK(other.waker_.is_unwakeable());
+      DCHECK(waker_.is_unwakeable());
+      CHECK(!other.saw_pending_);
+    }
+    Observer& operator=(Observer&& other) noexcept = delete;
+
+    void Wakeup() { waker_.WakeupAsync(); }
+
+    virtual bool ShouldReturn(const T& current) = 0;
+
+    Poll<T> operator()() {
+      MutexLock lock(state_->mu());
+      // Check if the value has changed yet.
+      if (ShouldReturn(state_->current())) {
+        if (saw_pending_ && !waker_.is_unwakeable()) state_->Remove(this);
+        return state_->current();
+      }
+      // Record that we saw at least one pending and then register for wakeup.
+      saw_pending_ = true;
+      if (waker_.is_unwakeable()) waker_ = state_->Add(this);
+      return Pending{};
+    }
+
+   private:
+    RefCountedPtr<State> state_;
+    Waker waker_;
+    bool saw_pending_ = false;
+  };
+
+  // A promise that resolves to a T when is_acceptable returns true for
+  // the current value.
+  template <typename F>
+  class ObserverWhen : public Observer {
+   public:
+    ObserverWhen(RefCountedPtr<State> state, F is_acceptable)
+        : Observer(std::move(state)),
+          is_acceptable_(std::move(is_acceptable)) {}
+
+    ObserverWhen(ObserverWhen&& other) noexcept
+        : Observer(std::move(other)),
+          is_acceptable_(std::move(other.is_acceptable_)) {}
+
+    bool ShouldReturn(const T& current) override {
+      return is_acceptable_(current);
+    }
+
+   private:
+    F is_acceptable_;
+  };
+
+  RefCountedPtr<State> state_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_OBSERVABLE_H

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

@@ -12,29 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/promise/party.h"
 
 #include <atomic>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
-#include "src/core/lib/promise/trace.h"
 
 #ifdef GRPC_MAXIMIZE_THREADYNESS
 #include "src/core/lib/gprpp/thd.h"       // IWYU pragma: keep
 #include "src/core/lib/iomgr/exec_ctx.h"  // IWYU pragma: keep
 #endif
 
-grpc_core::DebugOnlyTraceFlag grpc_trace_party_state(false, "party_state");
-
 namespace grpc_core {
 
 namespace {
@@ -103,7 +100,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();
-    GPR_ASSERT(party_ != nullptr);
+    CHECK_NE(party_, nullptr);
     party_ = nullptr;
     mu_.Unlock();
     Unref();
@@ -195,13 +192,13 @@ std::string Party::ActivityDebugTag(WakeupMask wakeup_mask) const {
 }
 
 Waker Party::MakeOwningWaker() {
-  GPR_DEBUG_ASSERT(currently_polling_ != kNotPolling);
+  DCHECK(currently_polling_ != kNotPolling);
   IncrementRefCount();
   return Waker(this, 1u << currently_polling_);
 }
 
 Waker Party::MakeNonOwningWaker() {
-  GPR_DEBUG_ASSERT(currently_polling_ != kNotPolling);
+  DCHECK(currently_polling_ != kNotPolling);
   return Waker(participants_[currently_polling_]
                    .load(std::memory_order_relaxed)
                    ->MakeNonOwningWakeable(this),
@@ -209,7 +206,7 @@ Waker Party::MakeNonOwningWaker() {
 }
 
 void Party::ForceImmediateRepoll(WakeupMask mask) {
-  GPR_DEBUG_ASSERT(is_current());
+  DCHECK(is_current());
   sync_.ForceImmediateRepoll(mask);
 }
 
@@ -233,11 +230,11 @@ void Party::RunLocked() {
     return;
   }
   auto body = [this]() {
-    GPR_DEBUG_ASSERT(g_current_party_run_next == nullptr);
+    DCHECK_EQ(g_current_party_run_next, nullptr);
     Party* run_next = nullptr;
     g_current_party_run_next = &run_next;
     const bool done = RunParty();
-    GPR_DEBUG_ASSERT(g_current_party_run_next == &run_next);
+    DCHECK(g_current_party_run_next == &run_next);
     g_current_party_run_next = nullptr;
     if (done) {
       ScopedActivity activity(this);
@@ -273,16 +270,16 @@ bool Party::RunOneParticipant(int i) {
   // somewhere.
   auto* participant = participants_[i].load(std::memory_order_acquire);
   if (participant == nullptr) {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_DEBUG, "%s[party] wakeup %d already complete",
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+      gpr_log(GPR_INFO, "%s[party] wakeup %d already complete",
               DebugTag().c_str(), i);
     }
     return false;
   }
   absl::string_view name;
-  if (grpc_trace_promise_primitives.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
     name = participant->name();
-    gpr_log(GPR_DEBUG, "%s[%s] begin job %d", DebugTag().c_str(),
+    gpr_log(GPR_INFO, "%s[%s] begin job %d", DebugTag().c_str(),
             std::string(name).c_str(), i);
   }
   // Poll the participant.
@@ -291,13 +288,13 @@ bool Party::RunOneParticipant(int i) {
   currently_polling_ = kNotPolling;
   if (done) {
     if (!name.empty()) {
-      gpr_log(GPR_DEBUG, "%s[%s] end poll and finish job %d",
-              DebugTag().c_str(), std::string(name).c_str(), i);
+      GRPC_TRACE_LOG(promise_primitives, INFO)
+          << DebugTag() << "[" << name << "] end poll and finish job " << i;
     }
     participants_[i].store(nullptr, std::memory_order_relaxed);
   } else if (!name.empty()) {
-    gpr_log(GPR_DEBUG, "%s[%s] end poll", DebugTag().c_str(),
-            std::string(name).c_str());
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << DebugTag() << "[" << name << "] end poll";
   }
   return done;
 }
@@ -306,10 +303,12 @@ void Party::AddParticipants(Participant** participants, size_t count) {
   bool run_party = sync_.AddParticipantsAndRef(count, [this, participants,
                                                        count](size_t* slots) {
     for (size_t i = 0; i < count; i++) {
-      if (grpc_trace_party_state.enabled()) {
-        gpr_log(GPR_DEBUG,
-                "Party %p                 AddParticipant: %s @ %" PRIdPTR,
-                &sync_, std::string(participants[i]->name()).c_str(), slots[i]);
+      if (GRPC_TRACE_FLAG_ENABLED(party_state)) {
+        gpr_log(GPR_INFO,
+                "Party %p                 AddParticipant: %s @ %" PRIdPTR
+                " [participant=%p]",
+                &sync_, std::string(participants[i]->name()).c_str(), slots[i],
+                participants[i]);
       }
       participants_[slots[i]].store(participants[i], std::memory_order_release);
     }

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_PARTY_H
 #define GRPC_SRC_CORE_LIB_PROMISE_PARTY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -26,11 +24,14 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -40,7 +41,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/promise/trace.h"
 
 // Two implementations of party synchronization are provided: one using a single
 // atomic, the other using a mutex and a set of state variables.
@@ -52,8 +52,6 @@
 // There's a thought of fuzzing the two implementations against each other as
 // a correctness check of both, but that's not implemented yet.
 
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_party_state;
-
 #define GRPC_PARTY_SYNC_USING_ATOMICS
 // #define GRPC_PARTY_SYNC_USING_MUTEX
 
@@ -116,7 +114,7 @@ class PartySyncUsingAtomics {
                                     std::memory_order_acquire);
       LogStateChange("Run", prev_state,
                      prev_state & (kRefMask | kLocked | kAllocatedMask));
-      GPR_ASSERT(prev_state & kLocked);
+      CHECK(prev_state & kLocked);
       if (prev_state & kDestroying) return true;
       // From the previous state, extract which participants we're to wakeup.
       uint64_t wakeups = prev_state & kWakeupMask;
@@ -196,7 +194,7 @@ class PartySyncUsingAtomics {
         slots[n++] = bit;
         allocated |= 1 << bit;
       }
-      GPR_ASSERT(n == count);
+      CHECK(n == count);
       // Try to allocate this slot and take a ref (atomically).
       // Ref needs to be taken because once we store the participant it could be
       // spuriously woken up and unref the party.
@@ -231,7 +229,7 @@ class PartySyncUsingAtomics {
 
   void LogStateChange(const char* op, uint64_t prev_state, uint64_t new_state,
                       DebugLocation loc = {}) {
-    if (grpc_trace_party_state.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(party_state)) {
       gpr_log(loc.file(), loc.line(), GPR_LOG_SEVERITY_INFO,
               "Party %p %30s: %016" PRIx64 " -> %016" PRIx64, this, op,
               prev_state, new_state);
@@ -294,7 +292,7 @@ class PartySyncUsingMutex {
     WakeupMask freed = 0;
     while (true) {
       ReleasableMutexLock lock(&mu_);
-      GPR_ASSERT(locked_);
+      CHECK(locked_);
       allocated_ &= ~std::exchange(freed, 0);
       auto wakeup = std::exchange(wakeups_, 0);
       if (wakeup == 0) {
@@ -323,7 +321,7 @@ class PartySyncUsingMutex {
       wakeup_mask |= 1 << bit;
       allocated_ |= 1 << bit;
     }
-    GPR_ASSERT(n == count);
+    CHECK(n == count);
     store(slots);
     wakeups_ |= wakeup_mask;
     return !std::exchange(locked_, true);
@@ -379,6 +377,11 @@ class Party : public Activity, private Wakeable {
   // The on_complete callback will be called with the result of the promise if
   // it completes.
   // A maximum of sixteen promises can be spawned onto a party.
+  // promise_factory called to create the promise with the party lock taken;
+  // after the promise is created the factory is destroyed.
+  // This means that pointers or references to factory members will be
+  // invalidated after the promise is created - so the promise should not retain
+  // any of these.
   template <typename Factory, typename OnComplete>
   void Spawn(absl::string_view name, Factory promise_factory,
              OnComplete on_complete);
@@ -391,7 +394,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 {
-    GPR_DEBUG_ASSERT(currently_polling_ != kNotPolling);
+    DCHECK(currently_polling_ != kNotPolling);
     return 1u << currently_polling_;
   }
   Waker MakeOwningWaker() final;
@@ -412,10 +415,10 @@ class Party : public Activity, private Wakeable {
   // This is useful for implementing batching and the like: we can hold some
   // action until the rest of the party resolves itself.
   auto AfterCurrentPoll() {
-    GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
+    DCHECK(GetContext<Activity>() == this);
     sync_.WakeAfterPoll(CurrentParticipant());
     return [this, iteration = sync_.iteration()]() -> Poll<Empty> {
-      GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
+      DCHECK(GetContext<Activity>() == this);
       if (iteration == sync_.iteration()) return Pending{};
       return Empty{};
     };
@@ -641,10 +644,9 @@ struct ContextSubclass<Party> {
 template <typename Factory, typename OnComplete>
 void Party::BulkSpawner::Spawn(absl::string_view name, Factory promise_factory,
                                OnComplete on_complete) {
-  if (grpc_trace_promise_primitives.enabled()) {
-    gpr_log(GPR_DEBUG, "%s[bulk_spawn] On %p queue %s",
-            party_->DebugTag().c_str(), this, std::string(name).c_str());
-  }
+  GRPC_TRACE_LOG(promise_primitives, INFO)
+      << party_->DebugTag() << "[bulk_spawn] On " << this << " queue " << name
+      << " (" << sizeof(ParticipantImpl<Factory, OnComplete>) << " bytes)";
   participants_[num_participants_++] = new ParticipantImpl<Factory, OnComplete>(
       name, std::move(promise_factory), std::move(on_complete));
 }

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_PIPE_H
 #define GRPC_SRC_CORE_LIB_PROMISE_PIPE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -24,11 +22,14 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -39,7 +40,6 @@
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/seq.h"
-#include "src/core/lib/promise/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
@@ -64,7 +64,7 @@ class NextResult final {
   NextResult() : center_(nullptr) {}
   explicit NextResult(RefCountedPtr<pipe_detail::Center<T>> center)
       : center_(std::move(center)) {
-    GPR_ASSERT(center_ != nullptr);
+    CHECK(center_ != nullptr);
   }
   explicit NextResult(bool cancelled)
       : center_(nullptr), cancelled_(cancelled) {}
@@ -80,17 +80,17 @@ class NextResult final {
   bool has_value() const;
   // Only valid if has_value()
   const T& value() const {
-    GPR_ASSERT(has_value());
+    CHECK(has_value());
     return **this;
   }
   T& value() {
-    GPR_ASSERT(has_value());
+    CHECK(has_value());
     return **this;
   }
   const T& operator*() const;
   T& operator*();
   // Only valid if !has_value()
-  bool cancelled() { return cancelled_; }
+  bool cancelled() const { return cancelled_; }
 
  private:
   RefCountedPtr<pipe_detail::Center<T>> center_;
@@ -118,11 +118,10 @@ class Center : public InterceptorList<T> {
 
   // Add one ref to this object, and return this.
   void IncrementRefCount() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_DEBUG, "%s", DebugOpString("IncrementRefCount").c_str());
-    }
+    GRPC_TRACE_VLOG(promise_primitives, 2)
+        << DebugOpString("IncrementRefCount");
     refs_++;
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    DCHECK_NE(refs_, 0);
   }
 
   RefCountedPtr<Center> Ref() {
@@ -133,10 +132,8 @@ class Center : public InterceptorList<T> {
   // Drop a ref
   // If no refs remain, destroy this object
   void Unref() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_DEBUG, "%s", DebugOpString("Unref").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ > 0);
+    GRPC_TRACE_VLOG(promise_primitives, 2) << DebugOpString("Unref");
+    DCHECK_GT(refs_, 0);
     refs_--;
     if (0 == refs_) {
       this->~Center();
@@ -148,10 +145,8 @@ class Center : public InterceptorList<T> {
   // Return true if the value was pushed.
   // Return false if the recv end is closed.
   Poll<bool> Push(T* value) {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("Push").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Push");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
       case ValueState::kReadyClosed:
@@ -172,10 +167,8 @@ class Center : public InterceptorList<T> {
   }
 
   Poll<bool> PollAck() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollAck").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollAck");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
         return true;
@@ -200,10 +193,8 @@ class Center : public InterceptorList<T> {
   // Return the value if one was retrieved.
   // Return nullopt if the send end is closed and no value had been pushed.
   Poll<absl::optional<T>> Next() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("Next").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Next");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -226,10 +217,9 @@ class Center : public InterceptorList<T> {
   // Check if the pipe is closed for sending (if there is a value still queued
   // but the pipe is closed, reports closed).
   Poll<bool> PollClosedForSender() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollClosedForSender").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << DebugOpString("PollClosedForSender");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -249,10 +239,9 @@ class Center : public InterceptorList<T> {
   // Check if the pipe is closed for receiving (if there is a value still queued
   // but the pipe is closed, reports open).
   Poll<bool> PollClosedForReceiver() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollClosedForReceiver").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << DebugOpString("PollClosedForReceiver");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -270,10 +259,8 @@ class Center : public InterceptorList<T> {
   }
 
   Poll<Empty> PollEmpty() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollEmpty").c_str());
-    }
-    GPR_DEBUG_ASSERT(refs_ != 0);
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollEmpty");
+    DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kReady:
       case ValueState::kReadyClosed:
@@ -290,9 +277,7 @@ class Center : public InterceptorList<T> {
   }
 
   void AckNext() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("AckNext").c_str());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("AckNext");
     switch (value_state_) {
       case ValueState::kReady:
       case ValueState::kWaitingForAck:
@@ -317,9 +302,7 @@ class Center : public InterceptorList<T> {
   }
 
   void MarkClosed() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("MarkClosed").c_str());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("MarkClosed");
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -346,9 +329,7 @@ class Center : public InterceptorList<T> {
   }
 
   void MarkCancelled() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("MarkCancelled").c_str());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("MarkCancelled");
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -654,7 +635,7 @@ class Push {
 
   Poll<bool> operator()() {
     if (center_ == nullptr) {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_DEBUG, "%s Pipe push has a null center",
                 GetContext<Activity>()->DebugTag().c_str());
       }
@@ -669,7 +650,7 @@ class Push {
         return Pending{};
       }
     }
-    GPR_DEBUG_ASSERT(absl::holds_alternative<AwaitingAck>(state_));
+    DCHECK(absl::holds_alternative<AwaitingAck>(state_));
     return center_->PollAck();
   }