grpc 1.72.0 → 1.78.1

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

@@ -23,23 +23,23 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/attributes.h"
-#include "absl/functional/function_ref.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/status_helper.h"
+#include "absl/base/attributes.h"
+#include "absl/functional/function_ref.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 namespace grpc_core {
 namespace promise_filter_detail {
@@ -84,7 +84,13 @@ BaseCallData::BaseCallData(
     grpc_call_element* elem, const grpc_call_element_args* args, uint8_t flags,
     absl::FunctionRef<Interceptor*()> make_send_interceptor,
     absl::FunctionRef<Interceptor*()> make_recv_interceptor)
-    : call_stack_(args->call_stack),
+    : channelz::DataSource([args]() -> RefCountedPtr<channelz::BaseNode> {
+        channelz::CallNode* call_node =
+            args->arena->GetContext<channelz::CallNode>();
+        if (call_node == nullptr) return nullptr;
+        return call_node->Ref();
+      }()),
+      call_stack_(args->call_stack),
       elem_(elem),
       arena_(args->arena),
       call_combiner_(args->call_combiner),
@@ -149,6 +155,37 @@ std::string BaseCallData::LogTag() const {
       absl::Hex(reinterpret_cast<uintptr_t>(elem_), absl::kZeroPad8), "]");
 }
 
+void BaseCallData::AddData(channelz::DataSink sink) {
+  EnsureRunInExecCtx([this, sink = std::move(sink)]() mutable {
+    auto add = [sink, this](grpc_error_handle) mutable {
+      sink.AddData(elem_->filter->name.name(), ChannelzProperties());
+      GRPC_CALL_COMBINER_STOP(call_combiner(), "channelz_add_data");
+      GRPC_CALL_STACK_UNREF(call_stack_, "channelz_add_data");
+    };
+    GRPC_CALL_STACK_REF(call_stack_, "channelz_add_data");
+    GRPC_CALL_COMBINER_START(call_combiner_, NewClosure(std::move(add)),
+                             absl::OkStatus(), "channelz_add_data");
+  });
+}
+
+channelz::PropertyList BaseCallData::ChannelzProperties() const {
+  channelz::PropertyList properties;
+  properties.Set("deadline", deadline_);
+  if (send_message_ != nullptr) {
+    properties.Set("promise_based_send_message",
+                   send_message_->ChannelzProperties());
+  }
+  if (receive_message_ != nullptr) {
+    properties.Set("promise_based_receive_message",
+                   receive_message_->ChannelzProperties());
+  }
+  if (server_initial_metadata_pipe_ != nullptr) {
+    properties.Set("server_initial_metadata_pipe",
+                   server_initial_metadata_pipe_->sender.ChannelzProperties());
+  }
+  return properties;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // BaseCallData::CapturedBatch
 
@@ -172,7 +209,7 @@ BaseCallData::CapturedBatch::~CapturedBatch() {
   uintptr_t& refcnt = *RefCountField(batch_);
   if (refcnt == 0) return;  // refcnt==0 ==> cancelled
   --refcnt;
-  CHECK_NE(refcnt, 0u);
+  GRPC_CHECK_NE(refcnt, 0u);
 }
 
 BaseCallData::CapturedBatch::CapturedBatch(const CapturedBatch& rhs)
@@ -203,7 +240,7 @@ BaseCallData::CapturedBatch& BaseCallData::CapturedBatch::operator=(
 
 void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
   auto* batch = std::exchange(batch_, nullptr);
-  CHECK_NE(batch, nullptr);
+  GRPC_CHECK_NE(batch, nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
@@ -218,7 +255,7 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
 
 void BaseCallData::CapturedBatch::CompleteWith(Flusher* releaser) {
   auto* batch = std::exchange(batch_, nullptr);
-  CHECK_NE(batch, nullptr);
+  GRPC_CHECK_NE(batch, nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) return;  // refcnt==0 ==> cancelled
   if (--refcnt == 0) {
@@ -229,7 +266,7 @@ void BaseCallData::CapturedBatch::CompleteWith(Flusher* releaser) {
 void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
                                              Flusher* releaser) {
   auto* batch = std::exchange(batch_, nullptr);
-  CHECK_NE(batch, nullptr);
+  GRPC_CHECK_NE(batch, nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
@@ -242,8 +279,7 @@ void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
 ///////////////////////////////////////////////////////////////////////////////
 // BaseCallData::Flusher
 
-BaseCallData::Flusher::Flusher(BaseCallData* call, latent_see::Metadata* desc)
-    : latent_see::InnerScope(desc), call_(call) {
+BaseCallData::Flusher::Flusher(BaseCallData* call) : call_(call) {
   GRPC_CALL_STACK_REF(call_->call_stack(), "flusher");
 }
 
@@ -352,7 +388,7 @@ template <typename T>
 void BaseCallData::SendMessage::GotPipe(T* pipe_end) {
   GRPC_TRACE_LOG(channel, INFO)
       << base_->LogTag() << " SendMessage.GotPipe st=" << StateString(state_);
-  CHECK_NE(pipe_end, nullptr);
+  GRPC_CHECK_NE(pipe_end, nullptr);
   switch (state_) {
     case State::kInitial:
       state_ = State::kIdle;
@@ -395,7 +431,7 @@ bool BaseCallData::SendMessage::IsIdle() const {
 }
 
 void BaseCallData::SendMessage::OnComplete(absl::Status status) {
-  Flusher flusher(base_, GRPC_LATENT_SEE_METADATA("SendMessage::OnComplete"));
+  Flusher flusher(base_);
   GRPC_TRACE_LOG(channel, INFO)
       << base_->LogTag() << " SendMessage.OnComplete st=" << StateString(state_)
       << " status=" << status;
@@ -496,7 +532,7 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       }
       [[fallthrough]];
     case State::kPushedToPipe: {
-      CHECK(push_.has_value());
+      GRPC_CHECK(push_.has_value());
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
         GRPC_TRACE_LOG(channel, INFO)
@@ -505,12 +541,12 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
                "result="
             << (*p ? "true" : "false");
         // We haven't pulled through yet, so this certainly shouldn't succeed.
-        CHECK(!*p);
+        GRPC_CHECK(!*p);
         state_ = State::kCancelled;
         batch_.CancelWith(absl::CancelledError(), flusher);
         break;
       }
-      CHECK(next_.has_value());
+      GRPC_CHECK(next_.has_value());
       auto r_next = (*next_)();
       if (auto* p = r_next.value_if_ready()) {
         GRPC_TRACE_LOG(channel, INFO)
@@ -705,8 +741,7 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
       break;
   }
   completed_status_ = status;
-  Flusher flusher(base_,
-                  GRPC_LATENT_SEE_METADATA("ReceiveMessage::OnComplete"));
+  Flusher flusher(base_);
   ScopedContext ctx(base_);
   base_->WakeInsideCombiner(&flusher);
 }
@@ -822,12 +857,12 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
                             completed_status_, "recv_message");
         break;
       }
-      CHECK(state_ == State::kPushedToPipe ||
-            state_ == State::kCompletedWhilePushedToPipe);
+      GRPC_CHECK(state_ == State::kPushedToPipe ||
+                 state_ == State::kCompletedWhilePushedToPipe);
       [[fallthrough]];
     case State::kCompletedWhilePushedToPipe:
     case State::kPushedToPipe: {
-      CHECK(push_.has_value());
+      GRPC_CHECK(push_.has_value());
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
         GRPC_TRACE_LOG(channel, INFO)
@@ -835,11 +870,11 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
             << " ReceiveMessage.WakeInsideCombiner push complete: "
             << (*p ? "true" : "false");
         // We haven't pulled through yet, so this certainly shouldn't succeed.
-        CHECK(!*p);
+        GRPC_CHECK(!*p);
         state_ = State::kCancelled;
         break;
       }
-      CHECK(next_.has_value());
+      GRPC_CHECK(next_.has_value());
       auto r_next = (*next_)();
       if (auto* p = r_next.value_if_ready()) {
         next_.reset();
@@ -874,7 +909,7 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       [[fallthrough]];
     case State::kCompletedWhilePulledFromPipe:
     case State::kPulledFromPipe: {
-      CHECK(push_.has_value());
+      GRPC_CHECK(push_.has_value());
       if ((*push_)().ready()) {
         GRPC_TRACE_LOG(channel, INFO)
             << base_->LogTag()
@@ -978,7 +1013,7 @@ class ClientCallData::PollContext {
  public:
   explicit PollContext(ClientCallData* self, Flusher* flusher)
       : self_(self), flusher_(flusher) {
-    CHECK_EQ(self_->poll_ctx_, nullptr);
+    GRPC_CHECK_EQ(self_->poll_ctx_, nullptr);
 
     self_->poll_ctx_ = this;
     scoped_activity_.Init(self_);
@@ -989,11 +1024,11 @@ class ClientCallData::PollContext {
   PollContext& operator=(const PollContext&) = delete;
 
   void Run() {
-    DCHECK(HasContext<Arena>());
+    GRPC_DCHECK(HasContext<Arena>());
     GRPC_TRACE_LOG(channel, INFO)
         << self_->LogTag() << " ClientCallData.PollContext.Run "
         << self_->DebugString();
-    CHECK(have_scoped_activity_);
+    GRPC_CHECK(have_scoped_activity_);
     repoll_ = false;
     if (self_->send_message() != nullptr) {
       self_->send_message()->WakeInsideCombiner(flusher_, true);
@@ -1028,8 +1063,10 @@ class ClientCallData::PollContext {
         case RecvInitialMetadata::kCompleteAndGotPipe:
           self_->recv_initial_metadata_->state =
               RecvInitialMetadata::kCompleteAndPushedToPipe;
-          CHECK(!self_->recv_initial_metadata_->metadata_push_.has_value());
-          CHECK(!self_->recv_initial_metadata_->metadata_next_.has_value());
+          GRPC_CHECK(
+              !self_->recv_initial_metadata_->metadata_push_.has_value());
+          GRPC_CHECK(
+              !self_->recv_initial_metadata_->metadata_next_.has_value());
           self_->recv_initial_metadata_->metadata_push_.emplace(
               self_->recv_initial_metadata_->server_initial_metadata_publisher
                   ->Push(ServerMetadataHandle(
@@ -1040,7 +1077,7 @@ class ClientCallData::PollContext {
               self_->server_initial_metadata_pipe()->receiver.Next());
           [[fallthrough]];
         case RecvInitialMetadata::kCompleteAndPushedToPipe: {
-          CHECK(self_->recv_initial_metadata_->metadata_next_.has_value());
+          GRPC_CHECK(self_->recv_initial_metadata_->metadata_next_.has_value());
           Poll<NextResult<ServerMetadataHandle>> p =
               (*self_->recv_initial_metadata_->metadata_next_)();
           if (NextResult<ServerMetadataHandle>* nr = p.value_if_ready()) {
@@ -1132,7 +1169,7 @@ class ClientCallData::PollContext {
             }
           } else {
             self_->cancelled_error_ = StatusFromMetadata(*md);
-            CHECK(!self_->cancelled_error_.ok());
+            GRPC_CHECK(!self_->cancelled_error_.ok());
             if (self_->recv_initial_metadata_ != nullptr) {
               switch (self_->recv_initial_metadata_->state) {
                 case RecvInitialMetadata::kInitial:
@@ -1170,7 +1207,7 @@ class ClientCallData::PollContext {
               self_->send_initial_metadata_batch_.CancelWith(
                   self_->cancelled_error_, flusher_);
             } else {
-              CHECK(
+              GRPC_CHECK(
                   self_->recv_trailing_state_ == RecvTrailingState::kInitial ||
                   self_->recv_trailing_state_ == RecvTrailingState::kForwarded);
               self_->call_combiner()->Cancel(self_->cancelled_error_);
@@ -1220,9 +1257,7 @@ class ClientCallData::PollContext {
         auto* next_poll = static_cast<NextPoll*>(p);
         {
           ScopedContext ctx(next_poll->call_data);
-          Flusher flusher(next_poll->call_data,
-                          GRPC_LATENT_SEE_METADATA(
-                              "ClientCallData::PollContext::~PollContext"));
+          Flusher flusher(next_poll->call_data);
           next_poll->call_data->WakeInsideCombiner(&flusher);
         }
         GRPC_CALL_STACK_UNREF(next_poll->call_stack, "re-poll");
@@ -1272,11 +1307,13 @@ ClientCallData::ClientCallData(grpc_call_element* elem,
   if (server_initial_metadata_pipe() != nullptr) {
     recv_initial_metadata_ = arena()->New<RecvInitialMetadata>();
   }
+  SourceConstructed();
 }
 
 ClientCallData::~ClientCallData() {
+  SourceDestructing();
   ScopedActivity scoped_activity(this);
-  CHECK_EQ(poll_ctx_, nullptr);
+  GRPC_CHECK_EQ(poll_ctx_, nullptr);
   if (recv_initial_metadata_ != nullptr) {
     recv_initial_metadata_->~RecvInitialMetadata();
   }
@@ -1290,7 +1327,7 @@ std::string ClientCallData::DebugTag() const {
 
 // Activity implementation.
 void ClientCallData::ForceImmediateRepoll(WakeupMask) {
-  CHECK_NE(poll_ctx_, nullptr);
+  GRPC_CHECK_NE(poll_ctx_, nullptr);
   poll_ctx_->Repoll();
 }
 
@@ -1351,16 +1388,17 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   // Fake out the activity based context.
   ScopedContext context(this);
   CapturedBatch batch(b);
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA("ClientCallData::StartBatch"));
+  Flusher flusher(this);
 
   GRPC_TRACE_LOG(channel, INFO) << LogTag() << " StartBatch " << DebugString();
 
   // If this is a cancel stream, cancel anything we have pending and propagate
   // the cancellation.
   if (batch->cancel_stream) {
-    CHECK(!batch->send_initial_metadata && !batch->send_trailing_metadata &&
-          !batch->send_message && !batch->recv_initial_metadata &&
-          !batch->recv_message && !batch->recv_trailing_metadata);
+    GRPC_CHECK(!batch->send_initial_metadata &&
+               !batch->send_trailing_metadata && !batch->send_message &&
+               !batch->recv_initial_metadata && !batch->recv_message &&
+               !batch->recv_trailing_metadata);
     PollContext poll_ctx(this, &flusher);
     Cancel(batch->payload->cancel_stream.cancel_error, &flusher);
     poll_ctx.Run();
@@ -1431,12 +1469,12 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
       batch.CancelWith(cancelled_error_, &flusher);
     } else {
       // Otherwise, we should not have seen a send_initial_metadata op yet.
-      CHECK(send_initial_state_ == SendInitialState::kInitial);
+      GRPC_CHECK(send_initial_state_ == SendInitialState::kInitial);
       // Mark ourselves as queued.
       send_initial_state_ = SendInitialState::kQueued;
       if (batch->recv_trailing_metadata) {
         // If there's a recv_trailing_metadata op, we queue that too.
-        CHECK(recv_trailing_state_ == RecvTrailingState::kInitial);
+        GRPC_CHECK(recv_trailing_state_ == RecvTrailingState::kInitial);
         recv_trailing_state_ = RecvTrailingState::kQueued;
       }
       // This is the queuing!
@@ -1451,7 +1489,7 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
     if (recv_trailing_state_ == RecvTrailingState::kCancelled) {
       batch.CancelWith(cancelled_error_, &flusher);
     } else {
-      CHECK(recv_trailing_state_ == RecvTrailingState::kInitial);
+      GRPC_CHECK(recv_trailing_state_ == RecvTrailingState::kInitial);
       recv_trailing_state_ = RecvTrailingState::kForwarded;
       HookRecvTrailingMetadata(batch);
     }
@@ -1527,7 +1565,7 @@ void ClientCallData::Cancel(grpc_error_handle error, Flusher* flusher) {
 // Begin running the promise - which will ultimately take some initial
 // metadata and return some trailing metadata.
 void ClientCallData::StartPromise(Flusher* flusher) {
-  CHECK(send_initial_state_ == SendInitialState::kQueued);
+  GRPC_CHECK(send_initial_state_ == SendInitialState::kQueued);
   ChannelFilter* filter = promise_filter_detail::ChannelFilterFromElem(elem());
 
   // Construct the promise.
@@ -1557,8 +1595,7 @@ void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
       << DebugString() << " error:" << error.ToString()
       << " md:" << recv_initial_metadata_->metadata->DebugString();
   ScopedContext context(this);
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA(
-                            "ClientCallData::RecvInitialMetadataReady"));
+  Flusher flusher(this);
   if (!error.ok()) {
     switch (recv_initial_metadata_->state) {
       case RecvInitialMetadata::kHookedWaitingForPipe:
@@ -1637,8 +1674,8 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
     CallArgs call_args) {
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << " ClientCallData.MakeNextPromise " << DebugString();
-  CHECK_NE(poll_ctx_, nullptr);
-  CHECK(send_initial_state_ == SendInitialState::kQueued);
+  GRPC_CHECK_NE(poll_ctx_, nullptr);
+  GRPC_CHECK(send_initial_state_ == SendInitialState::kQueued);
   send_initial_metadata_batch_->payload->send_initial_metadata
       .send_initial_metadata = call_args.client_initial_metadata.get();
   if (recv_initial_metadata_ != nullptr) {
@@ -1646,7 +1683,7 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
     // It might be the one we passed in - in which case we know this filter
     // only wants to examine the metadata, or it might be a new instance, in
     // which case we know the filter wants to mutate.
-    CHECK_NE(call_args.server_initial_metadata, nullptr);
+    GRPC_CHECK_NE(call_args.server_initial_metadata, nullptr);
     recv_initial_metadata_->server_initial_metadata_publisher =
         call_args.server_initial_metadata;
     switch (recv_initial_metadata_->state) {
@@ -1675,17 +1712,17 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
                 recv_initial_metadata_->state)));  // unreachable
     }
   } else {
-    CHECK_EQ(call_args.server_initial_metadata, nullptr);
+    GRPC_CHECK_EQ(call_args.server_initial_metadata, nullptr);
   }
   if (send_message() != nullptr) {
     send_message()->GotPipe(call_args.client_to_server_messages);
   } else {
-    CHECK_EQ(call_args.client_to_server_messages, nullptr);
+    GRPC_CHECK_EQ(call_args.client_to_server_messages, nullptr);
   }
   if (receive_message() != nullptr) {
     receive_message()->GotPipe(call_args.server_to_client_messages);
   } else {
-    CHECK_EQ(call_args.server_to_client_messages, nullptr);
+    GRPC_CHECK_EQ(call_args.server_to_client_messages, nullptr);
   }
   return ArenaPromise<ServerMetadataHandle>(
       [this]() { return PollTrailingMetadata(); });
@@ -1698,10 +1735,10 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
 Poll<ServerMetadataHandle> ClientCallData::PollTrailingMetadata() {
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << " ClientCallData.PollTrailingMetadata " << DebugString();
-  CHECK_NE(poll_ctx_, nullptr);
+  GRPC_CHECK_NE(poll_ctx_, nullptr);
   if (send_initial_state_ == SendInitialState::kQueued) {
     // First poll: pass the send_initial_metadata op down the stack.
-    CHECK(send_initial_metadata_batch_.is_captured());
+    GRPC_CHECK(send_initial_metadata_batch_.is_captured());
     send_initial_state_ = SendInitialState::kForwarded;
     if (recv_trailing_state_ == RecvTrailingState::kQueued) {
       // (and the recv_trailing_metadata op if it's part of the queuing)
@@ -1744,8 +1781,7 @@ void ClientCallData::RecvTrailingMetadataReadyCallback(
 }
 
 void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA(
-                            "ClientCallData::RecvTrailingMetadataReady"));
+  Flusher flusher(this);
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << " ClientCallData.RecvTrailingMetadataReady "
       << "recv_trailing_state=" << StateString(recv_trailing_state_)
@@ -1768,7 +1804,7 @@ void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
     SetStatusFromError(recv_trailing_metadata_, error);
   }
   // Record that we've got the callback.
-  CHECK(recv_trailing_state_ == RecvTrailingState::kForwarded);
+  GRPC_CHECK(recv_trailing_state_ == RecvTrailingState::kForwarded);
   recv_trailing_state_ = RecvTrailingState::kComplete;
   if (receive_message() != nullptr) {
     receive_message()->Done(*recv_trailing_metadata_, &flusher);
@@ -1796,16 +1832,23 @@ void ClientCallData::SetStatusFromError(grpc_metadata_batch* metadata,
 
 // Wakeup and poll the promise if appropriate.
 void ClientCallData::WakeInsideCombiner(Flusher* flusher) {
-  GRPC_LATENT_SEE_INNER_SCOPE("ClientCallData::WakeInsideCombiner");
+  GRPC_LATENT_SEE_SCOPE("ClientCallData::WakeInsideCombiner");
   PollContext(this, flusher).Run();
 }
 
 void ClientCallData::OnWakeup() {
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA("ClientCallData::OnWakeup"));
+  Flusher flusher(this);
   ScopedContext context(this);
   WakeInsideCombiner(&flusher);
 }
 
+channelz::PropertyList ClientCallData::ChannelzProperties() const {
+  return BaseCallData::ChannelzProperties()
+      .Set("promise", PromiseProperty(&promise_))
+      .Set("send_initial_state", StateString(send_initial_state_))
+      .Set("recv_trailing_state", StateString(recv_trailing_state_));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ServerCallData
 
@@ -1857,7 +1900,7 @@ class ServerCallData::PollContext {
           created_.line(), "; Old: ", self_->poll_ctx_->created_.file(), ":",
           self_->poll_ctx_->created_.line()));
     }
-    CHECK_EQ(self_->poll_ctx_, nullptr);
+    GRPC_CHECK_EQ(self_->poll_ctx_, nullptr);
     self_->poll_ctx_ = this;
     scoped_activity_.Init(self_);
     have_scoped_activity_ = true;
@@ -1877,9 +1920,7 @@ class ServerCallData::PollContext {
       auto run = [](void* p, grpc_error_handle) {
         auto* next_poll = static_cast<NextPoll*>(p);
         {
-          Flusher flusher(next_poll->call_data,
-                          GRPC_LATENT_SEE_METADATA(
-                              "ServerCallData::PollContext::~PollContext"));
+          Flusher flusher(next_poll->call_data);
           ScopedContext context(next_poll->call_data);
           next_poll->call_data->WakeInsideCombiner(&flusher);
         }
@@ -1957,15 +1998,17 @@ ServerCallData::ServerCallData(grpc_call_element* elem,
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_,
                     RecvTrailingMetadataReadyCallback, this,
                     grpc_schedule_on_exec_ctx);
+  SourceConstructed();
 }
 
 ServerCallData::~ServerCallData() {
+  SourceDestructing();
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << " ~ServerCallData " << DebugString();
   if (send_initial_metadata_ != nullptr) {
     send_initial_metadata_->~SendInitialMetadata();
   }
-  CHECK_EQ(poll_ctx_, nullptr);
+  GRPC_CHECK_EQ(poll_ctx_, nullptr);
 }
 
 std::string ServerCallData::DebugTag() const {
@@ -1974,7 +2017,7 @@ std::string ServerCallData::DebugTag() const {
 
 // Activity implementation.
 void ServerCallData::ForceImmediateRepoll(WakeupMask) {
-  CHECK_NE(poll_ctx_, nullptr);
+  GRPC_CHECK_NE(poll_ctx_, nullptr);
   poll_ctx_->Repoll();
 }
 
@@ -1983,7 +2026,7 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   // Fake out the activity based context.
   ScopedContext context(this);
   CapturedBatch batch(b);
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA("ServerCallData::StartBatch"));
+  Flusher flusher(this);
   bool wake = false;
 
   GRPC_TRACE_LOG(channel, INFO) << LogTag() << " StartBatch: " << DebugString();
@@ -1991,9 +2034,10 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   // If this is a cancel stream, cancel anything we have pending and
   // propagate the cancellation.
   if (batch->cancel_stream) {
-    CHECK(!batch->send_initial_metadata && !batch->send_trailing_metadata &&
-          !batch->send_message && !batch->recv_initial_metadata &&
-          !batch->recv_message && !batch->recv_trailing_metadata);
+    GRPC_CHECK(!batch->send_initial_metadata &&
+               !batch->send_trailing_metadata && !batch->send_message &&
+               !batch->recv_initial_metadata && !batch->recv_message &&
+               !batch->recv_trailing_metadata);
     PollContext poll_ctx(this, &flusher);
     Completed(batch->payload->cancel_stream.cancel_error,
               batch->payload->cancel_stream.tarpit, &flusher);
@@ -2008,11 +2052,11 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   // recv_initial_metadata: we hook the response of this so we can start the
   // promise at an appropriate time.
   if (batch->recv_initial_metadata) {
-    CHECK(!batch->send_initial_metadata && !batch->send_trailing_metadata &&
-          !batch->send_message && !batch->recv_message &&
-          !batch->recv_trailing_metadata);
+    GRPC_CHECK(!batch->send_initial_metadata &&
+               !batch->send_trailing_metadata && !batch->send_message &&
+               !batch->recv_message && !batch->recv_trailing_metadata);
     // Otherwise, we should not have seen a send_initial_metadata op yet.
-    CHECK(recv_initial_state_ == RecvInitialState::kInitial);
+    GRPC_CHECK(recv_initial_state_ == RecvInitialState::kInitial);
     // Hook the callback so we know when to start the promise.
     recv_initial_metadata_ =
         batch->payload->recv_initial_metadata.recv_initial_metadata;
@@ -2190,13 +2234,14 @@ void ServerCallData::Completed(grpc_error_handle error,
 //   - return a wrapper around PollTrailingMetadata as the promise.
 ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
     CallArgs call_args) {
-  CHECK(recv_initial_state_ == RecvInitialState::kComplete);
-  CHECK(std::move(call_args.client_initial_metadata).get() ==
-        recv_initial_metadata_);
+  GRPC_CHECK(recv_initial_state_ == RecvInitialState::kComplete);
+  GRPC_CHECK(std::move(call_args.client_initial_metadata).get() ==
+             recv_initial_metadata_);
   forward_recv_initial_metadata_callback_ = true;
   if (send_initial_metadata_ != nullptr) {
-    CHECK(send_initial_metadata_->server_initial_metadata_publisher == nullptr);
-    CHECK_NE(call_args.server_initial_metadata, nullptr);
+    GRPC_CHECK(send_initial_metadata_->server_initial_metadata_publisher ==
+               nullptr);
+    GRPC_CHECK_NE(call_args.server_initial_metadata, nullptr);
     send_initial_metadata_->server_initial_metadata_publisher =
         call_args.server_initial_metadata;
     switch (send_initial_metadata_->state) {
@@ -2219,17 +2264,17 @@ ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
         break;
     }
   } else {
-    CHECK_EQ(call_args.server_initial_metadata, nullptr);
+    GRPC_CHECK_EQ(call_args.server_initial_metadata, nullptr);
   }
   if (send_message() != nullptr) {
     send_message()->GotPipe(call_args.server_to_client_messages);
   } else {
-    CHECK_EQ(call_args.server_to_client_messages, nullptr);
+    GRPC_CHECK_EQ(call_args.server_to_client_messages, nullptr);
   }
   if (receive_message() != nullptr) {
     receive_message()->GotPipe(call_args.client_to_server_messages);
   } else {
-    CHECK_EQ(call_args.client_to_server_messages, nullptr);
+    GRPC_CHECK_EQ(call_args.client_to_server_messages, nullptr);
   }
   return ArenaPromise<ServerMetadataHandle>(
       [this]() { return PollTrailingMetadata(); });
@@ -2272,8 +2317,7 @@ void ServerCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << ": RecvTrailingMetadataReady error=" << error
       << " md=" << recv_trailing_metadata_->DebugString();
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA(
-                            "ServerCallData::RecvTrailingMetadataReady"));
+  Flusher flusher(this);
   PollContext poll_ctx(this, &flusher);
   Completed(error, recv_trailing_metadata_->get(GrpcTarPit()).has_value(),
             &flusher);
@@ -2287,11 +2331,10 @@ void ServerCallData::RecvInitialMetadataReadyCallback(void* arg,
 }
 
 void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA(
-                            "ServerCallData::RecvInitialMetadataReady"));
+  Flusher flusher(this);
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << ": RecvInitialMetadataReady " << error;
-  CHECK(recv_initial_state_ == RecvInitialState::kForwarded);
+  GRPC_CHECK(recv_initial_state_ == RecvInitialState::kForwarded);
   // If there was an error we just propagate that through
   if (!error.ok()) {
     recv_initial_state_ = RecvInitialState::kResponded;
@@ -2351,7 +2394,7 @@ std::string ServerCallData::DebugString() const {
 
 // Wakeup and poll the promise if appropriate.
 void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
-  GRPC_LATENT_SEE_INNER_SCOPE("ServerCallData::WakeInsideCombiner");
+  GRPC_LATENT_SEE_SCOPE("ServerCallData::WakeInsideCombiner");
   PollContext poll_ctx(this, flusher);
   GRPC_TRACE_LOG(channel, INFO)
       << LogTag() << ": WakeInsideCombiner " << DebugString();
@@ -2361,8 +2404,8 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
         SendInitialMetadata::kQueuedAndGotPipe) {
       send_initial_metadata_->state =
           SendInitialMetadata::kQueuedAndPushedToPipe;
-      CHECK(!send_initial_metadata_->metadata_push_.has_value());
-      CHECK(!send_initial_metadata_->metadata_next_.has_value());
+      GRPC_CHECK(!send_initial_metadata_->metadata_push_.has_value());
+      GRPC_CHECK(!send_initial_metadata_->metadata_next_.has_value());
       send_initial_metadata_->metadata_push_.emplace(
           send_initial_metadata_->server_initial_metadata_publisher->Push(
               ServerMetadataHandle(
@@ -2436,7 +2479,7 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
     if (send_initial_metadata_ != nullptr &&
         send_initial_metadata_->state ==
             SendInitialMetadata::kQueuedAndPushedToPipe) {
-      CHECK(send_initial_metadata_->metadata_next_.has_value());
+      GRPC_CHECK(send_initial_metadata_->metadata_next_.has_value());
       auto p = (*send_initial_metadata_->metadata_next_)();
       GRPC_TRACE_LOG(channel, INFO)
           << LogTag() << ": WakeInsideCombiner send_initial_metadata poll="
@@ -2483,7 +2526,7 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
               StateString(send_trailing_state_)));  // unreachable
           break;
         case SendTrailingState::kInitial: {
-          CHECK(*md->get_pointer(GrpcStatusMetadata()) != GRPC_STATUS_OK);
+          GRPC_CHECK(*md->get_pointer(GrpcStatusMetadata()) != GRPC_STATUS_OK);
           Completed(StatusFromMetadata(*md), md->get(GrpcTarPit()).has_value(),
                     flusher);
         } break;
@@ -2503,10 +2546,17 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
 }
 
 void ServerCallData::OnWakeup() {
-  Flusher flusher(this, GRPC_LATENT_SEE_METADATA("ServerCallData::OnWakeup"));
+  Flusher flusher(this);
   ScopedContext context(this);
   WakeInsideCombiner(&flusher);
 }
 
+channelz::PropertyList ServerCallData::ChannelzProperties() const {
+  return BaseCallData::ChannelzProperties()
+      .Set("promise", PromiseProperty(&promise_))
+      .Set("recv_initial_state", StateString(recv_initial_state_))
+      .Set("send_trailing_state", StateString(send_trailing_state_));
+}
+
 }  // namespace promise_filter_detail
 }  // namespace grpc_core