grpc 1.64.0 → 1.65.0.pre1

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

@@ -27,13 +27,13 @@
 #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/promise/activity.h"
 #include "src/core/lib/promise/detail/promise_factory.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/lib/promise/trace.h"
 
 namespace grpc_core {
 
@@ -164,14 +164,14 @@ class ForEach {
   }
 
   Poll<Result> PollReaderNext() {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%s PollReaderNext", DebugTag().c_str());
     }
     auto r = reader_next_();
     if (auto* p = r.value_if_ready()) {
       switch (NextValueTraits<ReaderResult>::Type(*p)) {
         case NextValueType::kValue: {
-          if (grpc_trace_promise_primitives.enabled()) {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
             gpr_log(GPR_INFO, "%s PollReaderNext: got value",
                     DebugTag().c_str());
           }
@@ -183,14 +183,14 @@ class ForEach {
           return PollAction();
         }
         case NextValueType::kEndOfStream: {
-          if (grpc_trace_promise_primitives.enabled()) {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
             gpr_log(GPR_INFO, "%s PollReaderNext: got end of stream",
                     DebugTag().c_str());
           }
           return Done<Result>::Make(false);
         }
         case NextValueType::kError: {
-          if (grpc_trace_promise_primitives.enabled()) {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
             gpr_log(GPR_INFO, "%s PollReaderNext: got error",
                     DebugTag().c_str());
           }
@@ -202,7 +202,7 @@ class ForEach {
   }
 
   Poll<Result> PollAction() {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%s PollAction", DebugTag().c_str());
     }
     auto r = in_action_.promise();

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

@@ -35,7 +35,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"
 #include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
@@ -88,7 +87,7 @@ class InterceptorList {
    public:
     RunPromise(size_t memory_required, Map** factory, absl::optional<T> value) {
       if (!value.has_value() || *factory == nullptr) {
-        if (grpc_trace_promise_primitives.enabled()) {
+        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
           gpr_log(GPR_DEBUG,
                   "InterceptorList::RunPromise[%p]: create immediate", this);
         }
@@ -101,7 +100,7 @@ class InterceptorList {
                                 async_resolution_.space.get());
         async_resolution_.current_factory = *factory;
         async_resolution_.first_factory = factory;
-        if (grpc_trace_promise_primitives.enabled()) {
+        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
           gpr_log(GPR_DEBUG,
                   "InterceptorList::RunPromise[%p]: create async; mem=%p", this,
                   async_resolution_.space.get());
@@ -110,7 +109,7 @@ class InterceptorList {
     }
 
     ~RunPromise() {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: destroy", this);
       }
       if (is_immediately_resolved_) {
@@ -129,7 +128,7 @@ class InterceptorList {
 
     RunPromise(RunPromise&& other) noexcept
         : is_immediately_resolved_(other.is_immediately_resolved_) {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: move from %p",
                 this, &other);
       }
@@ -143,7 +142,7 @@ class InterceptorList {
     RunPromise& operator=(RunPromise&& other) noexcept = delete;
 
     Poll<absl::optional<T>> operator()() {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
                 DebugString().c_str());
       }
@@ -161,7 +160,7 @@ class InterceptorList {
           async_resolution_.current_factory =
               async_resolution_.current_factory->next();
           if (!p->has_value()) async_resolution_.current_factory = nullptr;
-          if (grpc_trace_promise_primitives.enabled()) {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
             gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
                     DebugString().c_str());
           }

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

@@ -27,9 +27,9 @@
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/promise/trace.h"
 
 namespace grpc_core {
 
@@ -67,7 +67,7 @@ class Latch {
     has_had_waiters_ = true;
 #endif
     return [this]() -> Poll<T> {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_INFO, "%sWait %s", DebugTag().c_str(),
                 StateString().c_str());
       }
@@ -86,7 +86,7 @@ class Latch {
     has_had_waiters_ = true;
 #endif
     return [this]() -> Poll<T> {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_INFO, "%sWaitAndCopy %s", DebugTag().c_str(),
                 StateString().c_str());
       }
@@ -100,7 +100,7 @@ class Latch {
 
   // Set the value of the latch. Can only be called once.
   void Set(T value) {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
     }
     DCHECK(!has_value_);
@@ -163,7 +163,7 @@ class Latch<void> {
     has_had_waiters_ = true;
 #endif
     return [this]() -> Poll<Empty> {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
                 StateString().c_str());
       }
@@ -177,7 +177,7 @@ class Latch<void> {
 
   // Set the latch. Can only be called once.
   void Set() {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
     }
     DCHECK(!is_set_);
@@ -226,7 +226,7 @@ class ExternallyObservableLatch<void> {
   // Produce a promise to wait for this latch.
   auto Wait() {
     return [this]() -> Poll<Empty> {
-      if (grpc_trace_promise_primitives.enabled()) {
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
         gpr_log(GPR_INFO, "%sPollWait %s", DebugTag().c_str(),
                 StateString().c_str());
       }
@@ -240,7 +240,7 @@ class ExternallyObservableLatch<void> {
 
   // Set the latch.
   void Set() {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%sSet %s", DebugTag().c_str(), StateString().c_str());
     }
     is_set_.store(true, std::memory_order_relaxed);
@@ -250,7 +250,7 @@ class ExternallyObservableLatch<void> {
   bool IsSet() const { return is_set_.load(std::memory_order_relaxed); }
 
   void Reset() {
-    if (grpc_trace_promise_primitives.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
       gpr_log(GPR_INFO, "%sReset %s", DebugTag().c_str(),
               StateString().c_str());
     }

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

@@ -72,6 +72,23 @@ promise_detail::Map<Promise, Fn> Map(Promise promise, Fn fn) {
   return promise_detail::Map<Promise, Fn>(std::move(promise), std::move(fn));
 }
 
+// Maps a promise to a new promise that returns a tuple of the original result
+// and a bool indicating whether there was ever a Pending{} value observed from
+// polling.
+template <typename Promise>
+auto CheckDelayed(Promise promise) {
+  using P = promise_detail::PromiseLike<Promise>;
+  return [delayed = false, promise = P(std::move(promise))]() mutable
+         -> Poll<std::tuple<typename P::Result, bool>> {
+    auto r = promise();
+    if (r.pending()) {
+      delayed = true;
+      return Pending{};
+    }
+    return std::make_tuple(r.value(), delayed);
+  };
+}
+
 // Callable that takes a tuple and returns one element
 template <size_t kElem>
 struct JustElem {

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

@@ -26,15 +26,12 @@
 #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 {
@@ -273,14 +270,14 @@ bool Party::RunOneParticipant(int i) {
   // somewhere.
   auto* participant = participants_[i].load(std::memory_order_acquire);
   if (participant == nullptr) {
-    if (grpc_trace_promise_primitives.enabled()) {
+    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_INFO, "%s[%s] begin job %d", DebugTag().c_str(),
             std::string(name).c_str(), i);
@@ -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()) {
+      if (GRPC_TRACE_FLAG_ENABLED(party_state)) {
         gpr_log(GPR_INFO,
-                "Party %p                 AddParticipant: %s @ %" PRIdPTR,
-                &sync_, std::string(participants[i]->name()).c_str(), slots[i]);
+                "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

@@ -31,6 +31,7 @@
 #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
 
@@ -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);
@@ -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);
@@ -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

@@ -23,6 +23,7 @@
 #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"
@@ -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 {
@@ -118,9 +118,8 @@ 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_++;
     DCHECK_NE(refs_, 0);
   }
@@ -133,9 +132,7 @@ 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());
-    }
+    GRPC_TRACE_VLOG(promise_primitives, 2) << DebugOpString("Unref");
     DCHECK_GT(refs_, 0);
     refs_--;
     if (0 == refs_) {
@@ -148,9 +145,7 @@ 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());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Push");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
@@ -172,9 +167,7 @@ class Center : public InterceptorList<T> {
   }
 
   Poll<bool> PollAck() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollAck").c_str());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollAck");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
@@ -200,9 +193,7 @@ 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());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Next");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
@@ -226,9 +217,8 @@ 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());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << DebugOpString("PollClosedForSender");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
@@ -249,9 +239,8 @@ 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());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << DebugOpString("PollClosedForReceiver");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
@@ -270,9 +259,7 @@ class Center : public InterceptorList<T> {
   }
 
   Poll<Empty> PollEmpty() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_INFO, "%s", DebugOpString("PollEmpty").c_str());
-    }
+    GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollEmpty");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kReady:
@@ -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());
       }

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

@@ -18,6 +18,7 @@
 #include <type_traits>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 

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

@@ -171,6 +171,8 @@ class ValueOrFailure {
   T& value() { return value_.value(); }
   const T& operator*() const { return *value_; }
   T& operator*() { return *value_; }
+  const T* operator->() const { return &*value_; }
+  T* operator->() { return &*value_; }
 
   bool operator==(const ValueOrFailure& other) const {
     return value_ == other.value_;