grpc 1.76.0 → 1.78.0.pre1

data/src/core/handshaker/security/security_handshaker.cc

@@ -35,11 +35,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/attributes.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
@@ -64,6 +59,11 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/base/attributes.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 #define GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE 256
 
@@ -324,6 +324,9 @@ grpc_error_handle SecurityHandshaker::CheckPeerLocked() {
       });
   connector_->check_peer(peer, args_->endpoint.get(), args_->args,
                          &auth_context_, on_peer_checked_);
+  if (auth_context_ != nullptr) {
+    auth_context_->set_protocol(connector_->type().name());
+  }
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       auth_context_.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);

data/src/core/handshaker/security/security_handshaker.h

@@ -22,13 +22,13 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/security_connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -27,10 +27,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_factory.h"
@@ -53,6 +49,10 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/uri.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/lib/address_utils/parse_address.cc

@@ -41,17 +41,17 @@
 #endif  // GRPC_HAVE_UNIX_SOCKET
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/strip.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/util/grpc_if_nametoindex.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/string.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/strip.h"
 
 // IWYU pragma: no_include <arpa/inet.h>
 

data/src/core/lib/address_utils/parse_address.h

@@ -22,11 +22,11 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/uri.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 /// Populate \a resolved_addr from \a uri, whose path is expected to contain a
 /// unix socket path. Returns true upon success.

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -31,16 +31,16 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #ifdef GPR_WINDOWS

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -24,8 +24,8 @@
 
 #include <string>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/status/statusor.h"
 
 // Returns true if addr is an IPv4-mapped IPv6 address within the
 // ::ffff:0.0.0.0/96 range, or false otherwise.

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

@@ -32,13 +32,13 @@
 #include <string>
 #include <vector>
 
+#include "src/core/util/useful.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/lib/channel/channel_args.h

@@ -33,8 +33,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
@@ -45,6 +43,8 @@
 #include "src/core/util/ref_counted_string.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
 
 // TODO(hork): When we're ready to allow setting via a channel arg from the
 // application, replace this with a macro in

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

@@ -24,7 +24,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/log.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
@@ -58,20 +58,19 @@ static int register_get_name_fn = []() {
 //   per-filter memory, aligned to GPR_MAX_ALIGNMENT
 // }
 
-size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
-                               size_t filter_count) {
+size_t grpc_channel_stack_size(
+    const std::vector<grpc_core::FilterAndConfig>& filters) {
   // always need the header, and size for the channel elements
   size_t size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
-                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
                                                sizeof(grpc_channel_element));
-  size_t i;
 
   GRPC_CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
       << "GPR_MAX_ALIGNMENT must be a power of two";
 
   // add the size for each filter
-  for (i = 0; i < filter_count; i++) {
-    size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+  for (const auto& [filter, _] : filters) {
+    size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter->sizeof_channel_data);
   }
 
   return size;
@@ -114,13 +113,13 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
-    const grpc_channel_filter** filters, size_t filter_count,
+    std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& channel_args, const char* name,
     grpc_channel_stack* stack, const grpc_core::Blackboard* blackboard) {
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     LOG(INFO) << "CHANNEL_STACK: init " << name;
-    for (size_t i = 0; i < filter_count; i++) {
-      LOG(INFO) << "CHANNEL_STACK:   filter " << filters[i]->name;
+    for (const auto& [filter, _] : filters) {
+      LOG(INFO) << "CHANNEL_STACK:   filter " << filter->name;
     }
   }
 
@@ -128,31 +127,32 @@ grpc_error_handle grpc_channel_stack_init(
   stack->event_engine.Init(channel_args.GetObjectRef<EventEngine>());
   stack->stats_plugin_group.Init();
 
-  size_t call_size =
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
+  size_t call_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
+                                                    sizeof(grpc_call_element));
   grpc_channel_element* elems;
   grpc_channel_element_args args;
   char* user_data;
   size_t i;
 
-  stack->count = filter_count;
+  stack->count = filters.size();
   GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg,
                        name);
   elems = CHANNEL_ELEMS_FROM_STACK(stack);
   user_data = (reinterpret_cast<char*>(elems)) +
-              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters.size() *
                                              sizeof(grpc_channel_element));
 
   // init per-filter data
   args.blackboard = blackboard;
   grpc_error_handle first_error;
-  for (i = 0; i < filter_count; i++) {
+  for (i = 0; i < filters.size(); ++i) {
     args.channel_stack = stack;
     args.channel_args = channel_args;
     args.is_first = i == 0;
-    args.is_last = i == (filter_count - 1);
-    elems[i].filter = filters[i];
+    args.is_last = i == (filters.size() - 1);
+    args.config = std::move(filters[i].config);
+    elems[i].filter = filters[i].filter;
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
@@ -162,13 +162,14 @@ grpc_error_handle grpc_channel_stack_init(
       }
     }
     user_data +=
-        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
-    call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i].filter->sizeof_channel_data);
+    call_size +=
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i].filter->sizeof_call_data);
   }
 
   GRPC_CHECK(user_data > (char*)stack);
   GRPC_CHECK((uintptr_t)(user_data - (char*)stack) ==
-             grpc_channel_stack_size(filters, filter_count));
+             grpc_channel_stack_size(filters));
 
   stack->call_stack_size = call_size;
   stack->channelz_data_source.Init(

data/src/core/lib/channel/channel_stack.h

@@ -48,6 +48,7 @@
 #include <functional>
 #include <memory>
 
+#include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/debug/trace.h"
@@ -76,6 +77,7 @@ struct grpc_channel_element_args {
   grpc_core::ChannelArgs channel_args;
   int is_first;
   int is_last;
+  grpc_core::RefCountedPtr<const grpc_core::FilterConfig> config;
   const grpc_core::Blackboard* blackboard;
 };
 struct grpc_call_element_args {
@@ -267,12 +269,12 @@ size_t grpc_channel_stack_filter_instance_number(
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 
 // Determine memory required for a channel stack containing a set of filters
-size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
-                               size_t filter_count);
+size_t grpc_channel_stack_size(
+    const std::vector<grpc_core::FilterAndConfig>& filters);
 // Initialize a channel stack given some filters
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
-    const grpc_channel_filter** filters, size_t filter_count,
+    std::vector<grpc_core::FilterAndConfig> filters,
     const grpc_core::ChannelArgs& args, const char* name,
     grpc_channel_stack* stack,
     const grpc_core::Blackboard* blackboard = nullptr);

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

@@ -40,12 +40,16 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
-  stack_.insert(stack_.begin(), filter);
+void ChannelStackBuilder::PrependFilter(
+    const grpc_channel_filter* filter,
+    RefCountedPtr<const FilterConfig> config) {
+  stack_.insert(stack_.begin(), {filter, std::move(config)});
 }
 
-void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter) {
-  stack_.push_back(filter);
+void ChannelStackBuilder::AppendFilter(
+    const grpc_channel_filter* filter,
+    RefCountedPtr<const FilterConfig> config) {
+  stack_.push_back({filter, std::move(config)});
 }
 
 }  // namespace grpc_core

data/src/core/lib/channel/channel_stack_builder.h

@@ -20,12 +20,13 @@
 #include <string>
 #include <vector>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
+#include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -53,12 +54,10 @@ class ChannelStackBuilder {
   const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
-  std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
+  std::vector<FilterAndConfig>* mutable_stack() { return &stack_; }
 
   // Immutable vector of proposed stack entries.
-  const std::vector<const grpc_channel_filter*>& stack() const {
-    return stack_;
-  }
+  const std::vector<FilterAndConfig>& stack() const { return stack_; }
 
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
@@ -68,10 +67,12 @@ class ChannelStackBuilder {
   // channel init.
 
   // Helper to add a filter to the front of the stack.
-  void PrependFilter(const grpc_channel_filter* filter);
+  void PrependFilter(const grpc_channel_filter* filter,
+                     RefCountedPtr<const FilterConfig> config = nullptr);
 
   // Helper to add a filter to the end of the stack.
-  void AppendFilter(const grpc_channel_filter* filter);
+  void AppendFilter(const grpc_channel_filter* filter,
+                    RefCountedPtr<const FilterConfig> config = nullptr);
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
@@ -95,7 +96,7 @@ class ChannelStackBuilder {
   // Channel args
   ChannelArgs args_;
   // The in-progress stack
-  std::vector<const grpc_channel_filter*> stack_;
+  std::vector<FilterAndConfig> stack_;
 };
 
 }  // namespace grpc_core

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

@@ -29,10 +29,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -47,20 +43,19 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
 ChannelStackBuilderImpl::Build() {
-  std::vector<const grpc_channel_filter*> stack;
-
-  for (const auto* filter : this->stack()) {
-    stack.push_back(filter);
-  }
+  std::vector<FilterAndConfig> stack = this->stack();
 
   // calculate the size of the channel stack
-  size_t channel_stack_size =
-      grpc_channel_stack_size(stack.data(), stack.size());
+  size_t channel_stack_size = grpc_channel_stack_size(stack);
 
   // allocate memory
   auto* channel_stack =
@@ -75,8 +70,7 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack.data(), stack.size(), channel_args(), name(),
-      channel_stack, blackboard_);
+      channel_stack, stack, channel_args(), name(), channel_stack, blackboard_);
 
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);

data/src/core/lib/channel/channel_stack_builder_impl.h

@@ -17,10 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

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

@@ -31,8 +31,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/call/call_finalization.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
@@ -74,6 +72,8 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 typedef struct connected_channel_channel_data {
   grpc_core::Transport* transport;

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

@@ -23,13 +23,6 @@
 #include <utility>
 #include <vector>
 
-#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"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/error.h"
@@ -40,6 +33,13 @@
 #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
 
@@ -1270,9 +1307,11 @@ 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);
   GRPC_CHECK_EQ(poll_ctx_, nullptr);
   if (recv_initial_metadata_ != nullptr) {
@@ -1803,6 +1842,13 @@ void ClientCallData::OnWakeup() {
   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
 
@@ -1952,9 +1998,11 @@ 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) {
@@ -2503,5 +2551,12 @@ void ServerCallData::OnWakeup() {
   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