grpc 1.63.0 → 1.66.0

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

@@ -15,13 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
 #define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_STATUS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
+#include <grpc/support/port_platform.h>
+
 // Helpers for dealing with absl::Status/StatusOr generically
 
 namespace grpc_core {
@@ -29,12 +30,14 @@ namespace promise_detail {
 
 // Convert with a move the input status to an absl::Status.
 template <typename T>
-absl::Status IntoStatus(absl::StatusOr<T>* status) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION absl::Status IntoStatus(
+    absl::StatusOr<T>* status) {
   return std::move(status->status());
 }
 
 // Convert with a move the input status to an absl::Status.
-inline absl::Status IntoStatus(absl::Status* status) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline absl::Status IntoStatus(
+    absl::Status* status) {
   return std::move(*status);
 }
 
@@ -43,10 +46,14 @@ inline absl::Status IntoStatus(absl::Status* status) {
 // Return true if the status represented by the argument is ok, false if not.
 // By implementing this function for other, non-absl::Status types, those types
 // can participate in TrySeq as result types that affect control flow.
-inline bool IsStatusOk(const absl::Status& status) { return status.ok(); }
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
+    const absl::Status& status) {
+  return status.ok();
+}
 
 template <typename T>
-inline bool IsStatusOk(const absl::StatusOr<T>& status) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool IsStatusOk(
+    const absl::StatusOr<T>& status) {
   return status.ok();
 }
 
@@ -55,29 +62,38 @@ struct StatusCastImpl;
 
 template <typename To>
 struct StatusCastImpl<To, To> {
-  static To Cast(To&& t) { return std::move(t); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static To Cast(To&& t) {
+    return std::move(t);
+  }
 };
 
 template <typename To>
 struct StatusCastImpl<To, const To&> {
-  static To Cast(const To& t) { return t; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static To Cast(const To& t) { return t; }
 };
 
 template <typename T>
 struct StatusCastImpl<absl::Status, absl::StatusOr<T>> {
-  static absl::Status Cast(absl::StatusOr<T>&& t) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      absl::StatusOr<T>&& t) {
     return std::move(t.status());
   }
 };
 
 template <typename T>
 struct StatusCastImpl<absl::Status, absl::StatusOr<T>&> {
-  static absl::Status Cast(const absl::StatusOr<T>& t) { return t.status(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      const absl::StatusOr<T>& t) {
+    return t.status();
+  }
 };
 
 template <typename T>
 struct StatusCastImpl<absl::Status, const absl::StatusOr<T>&> {
-  static absl::Status Cast(const absl::StatusOr<T>& t) { return t.status(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(
+      const absl::StatusOr<T>& t) {
+    return t.status();
+  }
 };
 
 // StatusCast<> allows casting from one status-bearing type to another,
@@ -87,7 +103,7 @@ struct StatusCastImpl<absl::Status, const absl::StatusOr<T>&> {
 // For cases where the status is guaranteed to be a failure (and hence not
 // needing to preserve values) see FailureStatusCast<> below.
 template <typename To, typename From>
-To StatusCast(From&& from) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION To StatusCast(From&& from) {
   return StatusCastImpl<To, From>::Cast(std::forward<From>(from));
 }
 
@@ -96,17 +112,23 @@ struct FailureStatusCastImpl : public StatusCastImpl<To, From> {};
 
 template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, absl::Status> {
-  static absl::StatusOr<T> Cast(absl::Status&& t) { return std::move(t); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      absl::Status&& t) {
+    return std::move(t);
+  }
 };
 
 template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, const absl::Status&> {
-  static absl::StatusOr<T> Cast(const absl::Status& t) { return t; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
+      const absl::Status& t) {
+    return t;
+  }
 };
 
 template <typename To, typename From>
-To FailureStatusCast(From&& from) {
-  GPR_DEBUG_ASSERT(!IsStatusOk(from));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION To FailureStatusCast(From&& from) {
+  DCHECK(!IsStatusOk(from));
   return FailureStatusCastImpl<To, From>::Cast(std::forward<From>(from));
 }
 

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

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
 #define GRPC_SRC_CORE_LIB_PROMISE_EXEC_CTX_WAKEUP_SCHEDULER_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/status/status.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"

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

@@ -15,25 +15,25 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_FOR_EACH_H
 #define GRPC_SRC_CORE_LIB_PROMISE_FOR_EACH_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.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/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 {
 
@@ -47,14 +47,60 @@ struct Done;
 
 template <>
 struct Done<absl::Status> {
-  static absl::Status Make(bool cancelled) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Make(
+      bool cancelled) {
     return cancelled ? absl::CancelledError() : absl::OkStatus();
   }
 };
 
 template <>
 struct Done<StatusFlag> {
-  static StatusFlag Make(bool cancelled) { return StatusFlag(!cancelled); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static StatusFlag Make(bool cancelled) {
+    return StatusFlag(!cancelled);
+  }
+};
+
+template <typename T, typename SfinaeVoid = void>
+struct NextValueTraits;
+
+enum class NextValueType {
+  kValue,
+  kEndOfStream,
+  kError,
+};
+
+template <typename T>
+struct NextValueTraits<T, absl::void_t<typename T::value_type>> {
+  using Value = typename T::value_type;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static NextValueType Type(const T& t) {
+    if (t.has_value()) return NextValueType::kValue;
+    if (t.cancelled()) return NextValueType::kError;
+    return NextValueType::kEndOfStream;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Value& MutableValue(T& t) {
+    return *t;
+  }
+};
+
+template <typename T>
+struct NextValueTraits<ValueOrFailure<absl::optional<T>>> {
+  using Value = T;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static NextValueType Type(
+      const ValueOrFailure<absl::optional<T>>& t) {
+    if (t.ok()) {
+      if (t.value().has_value()) return NextValueType::kValue;
+      return NextValueType::kEndOfStream;
+    }
+    return NextValueType::kError;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Value& MutableValue(
+      ValueOrFailure<absl::optional<T>>& t) {
+    return **t;
+  }
 };
 
 template <typename Reader, typename Action>
@@ -63,7 +109,7 @@ class ForEach {
   using ReaderNext = decltype(std::declval<Reader>().Next());
   using ReaderResult =
       typename PollTraits<decltype(std::declval<ReaderNext>()())>::Type;
-  using ReaderResultValue = typename ReaderResult::value_type;
+  using ReaderResultValue = typename NextValueTraits<ReaderResult>::Value;
   using ActionFactory =
       promise_detail::RepeatedPromiseFactory<ReaderResultValue, Action>;
   using ActionPromise = typename ActionFactory::Promise;
@@ -71,11 +117,14 @@ class ForEach {
  public:
   using Result =
       typename PollTraits<decltype(std::declval<ActionPromise>()())>::Type;
-  ForEach(Reader reader, Action action)
-      : reader_(std::move(reader)), action_factory_(std::move(action)) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ForEach(Reader reader, Action action,
+                                               DebugLocation whence = {})
+      : reader_(std::move(reader)),
+        action_factory_(std::move(action)),
+        whence_(whence) {
     Construct(&reader_next_, reader_.Next());
   }
-  ~ForEach() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~ForEach() {
     if (reading_next_) {
       Destruct(&reader_next_);
     } else {
@@ -87,17 +136,19 @@ class ForEach {
   ForEach& operator=(const ForEach&) = delete;
   ForEach(ForEach&& other) noexcept
       : reader_(std::move(other.reader_)),
-        action_factory_(std::move(other.action_factory_)) {
-    GPR_DEBUG_ASSERT(reading_next_);
-    GPR_DEBUG_ASSERT(other.reading_next_);
+        action_factory_(std::move(other.action_factory_)),
+        whence_(other.whence_) {
+    DCHECK(reading_next_);
+    DCHECK(other.reading_next_);
     Construct(&reader_next_, std::move(other.reader_next_));
   }
   ForEach& operator=(ForEach&& other) noexcept {
-    GPR_DEBUG_ASSERT(reading_next_);
-    GPR_DEBUG_ASSERT(other.reading_next_);
+    DCHECK(reading_next_);
+    DCHECK(other.reading_next_);
     reader_ = std::move(other.reader_);
     action_factory_ = std::move(other.action_factory_);
     reader_next_ = std::move(other.reader_next_);
+    whence_ = other.whence_;
     return *this;
   }
 
@@ -116,35 +167,48 @@ class ForEach {
 
   std::string DebugTag() {
     return absl::StrCat(GetContext<Activity>()->DebugTag(), " FOR_EACH[0x",
-                        reinterpret_cast<uintptr_t>(this), "]: ");
+                        reinterpret_cast<uintptr_t>(this), "@", whence_.file(),
+                        ":", whence_.line(), "]: ");
   }
 
-  Poll<Result> PollReaderNext() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_DEBUG, "%s PollReaderNext", DebugTag().c_str());
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollReaderNext() {
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+      LOG(INFO) << DebugTag() << " PollReaderNext";
     }
     auto r = reader_next_();
     if (auto* p = r.value_if_ready()) {
-      if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_DEBUG, "%s PollReaderNext: got has_value=%s",
-                DebugTag().c_str(), p->has_value() ? "true" : "false");
-      }
-      if (p->has_value()) {
-        Destruct(&reader_next_);
-        auto action = action_factory_.Make(std::move(**p));
-        Construct(&in_action_, std::move(action), std::move(*p));
-        reading_next_ = false;
-        return PollAction();
-      } else {
-        return Done<Result>::Make(p->cancelled());
+      switch (NextValueTraits<ReaderResult>::Type(*p)) {
+        case NextValueType::kValue: {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+            LOG(INFO) << DebugTag() << " PollReaderNext: got value";
+          }
+          Destruct(&reader_next_);
+          auto action = action_factory_.Make(
+              std::move(NextValueTraits<ReaderResult>::MutableValue(*p)));
+          Construct(&in_action_, std::move(action), std::move(*p));
+          reading_next_ = false;
+          return PollAction();
+        }
+        case NextValueType::kEndOfStream: {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+            LOG(INFO) << DebugTag() << " PollReaderNext: got end of stream";
+          }
+          return Done<Result>::Make(false);
+        }
+        case NextValueType::kError: {
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+            LOG(INFO) << DebugTag() << " PollReaderNext: got error";
+          }
+          return Done<Result>::Make(true);
+        }
       }
     }
     return Pending();
   }
 
   Poll<Result> PollAction() {
-    if (grpc_trace_promise_primitives.enabled()) {
-      gpr_log(GPR_DEBUG, "%s PollAction", DebugTag().c_str());
+    if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+      LOG(INFO) << DebugTag() << " PollAction";
     }
     auto r = in_action_.promise();
     if (auto* p = r.value_if_ready()) {
@@ -162,6 +226,7 @@ class ForEach {
 
   GPR_NO_UNIQUE_ADDRESS Reader reader_;
   GPR_NO_UNIQUE_ADDRESS ActionFactory action_factory_;
+  GPR_NO_UNIQUE_ADDRESS DebugLocation whence_;
   bool reading_next_ = true;
   union {
     ReaderNext reader_next_;
@@ -173,9 +238,10 @@ class ForEach {
 
 /// For each item acquired by calling Reader::Next, run the promise Action.
 template <typename Reader, typename Action>
-for_each_detail::ForEach<Reader, Action> ForEach(Reader reader, Action action) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION for_each_detail::ForEach<Reader, Action>
+ForEach(Reader reader, Action action, DebugLocation whence = {}) {
   return for_each_detail::ForEach<Reader, Action>(std::move(reader),
-                                                  std::move(action));
+                                                  std::move(action), whence);
 }
 
 }  // namespace grpc_core

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

@@ -15,14 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_IF_H
 #define GRPC_SRC_CORE_LIB_PROMISE_IF_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <utility>
 
 #include "absl/status/statusor.h"
 #include "absl/types/variant.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/promise_like.h"
@@ -33,8 +33,8 @@ namespace grpc_core {
 namespace promise_detail {
 
 template <typename CallPoll, typename T, typename F>
-typename CallPoll::PollResult ChooseIf(CallPoll call_poll, bool result,
-                                       T* if_true, F* if_false) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION typename CallPoll::PollResult ChooseIf(
+    CallPoll call_poll, bool result, T* if_true, F* if_false) {
   if (result) {
     auto promise = if_true->Make();
     return call_poll(promise);
@@ -45,9 +45,8 @@ typename CallPoll::PollResult ChooseIf(CallPoll call_poll, bool result,
 }
 
 template <typename CallPoll, typename T, typename F>
-typename CallPoll::PollResult ChooseIf(CallPoll call_poll,
-                                       absl::StatusOr<bool> result, T* if_true,
-                                       F* if_false) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION typename CallPoll::PollResult ChooseIf(
+    CallPoll call_poll, absl::StatusOr<bool> result, T* if_true, F* if_false) {
   if (!result.ok()) {
     return typename CallPoll::PollResult(result.status());
   } else if (*result) {
@@ -71,12 +70,12 @@ class If {
       typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
 
  public:
-  If(C condition, T if_true, F if_false)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(C condition, T if_true, F if_false)
       : state_(Evaluating{ConditionPromise(std::move(condition)),
                           TrueFactory(std::move(if_true)),
                           FalseFactory(std::move(if_false))}) {}
 
-  Poll<Result> operator()() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
     return absl::visit(CallPoll<false>{this}, state_);
   }
 
@@ -95,7 +94,8 @@ class If {
 
     If* const self;
 
-    PollResult operator()(Evaluating& evaluating) const {
+    GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION PollResult
+    operator()(Evaluating& evaluating) const {
       static_assert(
           !kSetState,
           "shouldn't need to set state coming through the initial branch");
@@ -108,7 +108,8 @@ class If {
     }
 
     template <class Promise>
-    PollResult operator()(Promise& promise) const {
+    GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION PollResult
+    operator()(Promise& promise) const {
       auto r = promise();
       if (kSetState && r.pending()) {
         self->state_.template emplace<Promise>(std::move(promise));
@@ -129,7 +130,8 @@ class If<bool, T, F> {
       typename PollTraits<decltype(std::declval<TruePromise>()())>::Type;
 
  public:
-  If(bool condition, T if_true, F if_false) : condition_(condition) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(bool condition, T if_true, F if_false)
+      : condition_(condition) {
     TrueFactory true_factory(std::move(if_true));
     FalseFactory false_factory(std::move(if_false));
     if (condition_) {
@@ -138,7 +140,7 @@ class If<bool, T, F> {
       Construct(&if_false_, false_factory.Make());
     }
   }
-  ~If() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~If() {
     if (condition_) {
       Destruct(&if_true_);
     } else {
@@ -148,21 +150,22 @@ class If<bool, T, F> {
 
   If(const If&) = delete;
   If& operator=(const If&) = delete;
-  If(If&& other) noexcept : condition_(other.condition_) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If(If&& other) noexcept
+      : condition_(other.condition_) {
     if (condition_) {
       Construct(&if_true_, std::move(other.if_true_));
     } else {
       Construct(&if_false_, std::move(other.if_false_));
     }
   }
-  If& operator=(If&& other) noexcept {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION If& operator=(If&& other) noexcept {
     if (&other == this) return *this;
     Destruct(this);
     Construct(this, std::move(other));
     return *this;
   }
 
-  Poll<Result> operator()() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
 #ifndef NDEBUG
     asan_canary_ = std::make_unique<int>(1 + *asan_canary_);
 #endif
@@ -197,7 +200,8 @@ class If<bool, T, F> {
 // This makes it safe to capture lambda arguments in the promise factory by
 // reference.
 template <typename C, typename T, typename F>
-promise_detail::If<C, T, F> If(C condition, T if_true, F if_false) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::If<C, T, F> If(
+    C condition, T if_true, F if_false) {
   return promise_detail::If<C, T, F>(std::move(condition), std::move(if_true),
                                      std::move(if_false));
 }

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_PROMISE_INTERCEPTOR_LIST_H
 #define GRPC_SRC_CORE_LIB_PROMISE_INTERCEPTOR_LIST_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <algorithm>
@@ -24,18 +22,19 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #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 {
@@ -67,7 +66,7 @@ class InterceptorList {
     // Update the next pointer stored with this map.
     // This is only valid to call once, and only before the map is used.
     void SetNext(Map* next) {
-      GPR_DEBUG_ASSERT(next_ == nullptr);
+      DCHECK_EQ(next_, nullptr);
       next_ = next;
     }
 
@@ -88,9 +87,9 @@ 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()) {
-          gpr_log(GPR_DEBUG,
-                  "InterceptorList::RunPromise[%p]: create immediate", this);
+        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+          VLOG(2) << "InterceptorList::RunPromise[" << this
+                  << "]: create immediate";
         }
         is_immediately_resolved_ = true;
         Construct(&result_, std::move(value));
@@ -101,17 +100,16 @@ class InterceptorList {
                                 async_resolution_.space.get());
         async_resolution_.current_factory = *factory;
         async_resolution_.first_factory = factory;
-        if (grpc_trace_promise_primitives.enabled()) {
-          gpr_log(GPR_DEBUG,
-                  "InterceptorList::RunPromise[%p]: create async; mem=%p", this,
-                  async_resolution_.space.get());
+        if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+          VLOG(2) << "InterceptorList::RunPromise[" << this
+                  << "]: create async; mem=" << async_resolution_.space.get();
         }
       }
     }
 
     ~RunPromise() {
-      if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: destroy", this);
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+        VLOG(2) << "InterceptorList::RunPromise[" << this << "]: destroy";
       }
       if (is_immediately_resolved_) {
         Destruct(&result_);
@@ -129,9 +127,9 @@ class InterceptorList {
 
     RunPromise(RunPromise&& other) noexcept
         : is_immediately_resolved_(other.is_immediately_resolved_) {
-      if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: move from %p",
-                this, &other);
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+        VLOG(2) << "InterceptorList::RunPromise[" << this << "]: move from "
+                << &other;
       }
       if (is_immediately_resolved_) {
         Construct(&result_, std::move(other.result_));
@@ -143,9 +141,9 @@ class InterceptorList {
     RunPromise& operator=(RunPromise&& other) noexcept = delete;
 
     Poll<absl::optional<T>> operator()() {
-      if (grpc_trace_promise_primitives.enabled()) {
-        gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
-                DebugString().c_str());
+      if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+        VLOG(2) << "InterceptorList::RunPromise[" << this
+                << "]: " << DebugString();
       }
       if (is_immediately_resolved_) return std::move(result_);
       while (true) {
@@ -161,9 +159,9 @@ 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()) {
-            gpr_log(GPR_DEBUG, "InterceptorList::RunPromise[%p]: %s", this,
-                    DebugString().c_str());
+          if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
+            VLOG(2) << "InterceptorList::RunPromise[" << this
+                    << "]: " << DebugString();
           }
           if (async_resolution_.current_factory == nullptr) {
             return std::move(*p);