grpc 1.76.0 → 1.78.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 756fcf0015ec334c4c7ed2efcc9507ea8efac9f564bff3940b47b0c990c8415b
-  data.tar.gz: 9dc842d0c9f08876ae645f9ed2c15dc54f118a99931de0bdda6f42414a516683
+  metadata.gz: 15b6af66bcb097912b531f2dfca1495387ea761175cc23186ae8db7a98e69a61
+  data.tar.gz: aac8c0d5fc00fa52956b6fbf48cbef1448be26b68a4e2a7067fb58acc395f621
 SHA512:
-  metadata.gz: 79f60eacb2ba9a0e03541ca765dbd34a61592a2298b982ee9b01608b3da48eee7867870573b8739f1c968ebf757af7fb2fcbe56a5eee3939a3cfcb639e7cb9f9
-  data.tar.gz: d1b4bf5eb377212da94b969ada4fdab5b5180c0ab19cb6814acb83b9b17518b3aec48280df6c40434251612d692f93972f5c4a30fc6ac5133fe2cedbe9feea37
+  metadata.gz: b6cab367569ec55bd13a330d45721567c979813eeb13a4fd807a8e6bb8e4a65c110d5b6b940af3f6da3991ddd9703689c9f350f544155531211d391ed7b00386
+  data.tar.gz: e1d6526a229394bf63cb2192adf515093d24720e296cd85237e57ce96e3c6252d6d13993ca4f22185578e00c44e280182d7f327612890a4217fa11ad59fe6b89

data/Makefile

@@ -367,8 +367,8 @@ E = @echo
 Q = @
 endif
 
-CORE_VERSION = 51.0.0
-CPP_VERSION = 1.76.0
+CORE_VERSION = 52.0.0
+CPP_VERSION = 1.78.0-pre1
 
 CPPFLAGS_NO_ARCH += $(addprefix -I, $(INCLUDES)) $(addprefix -D, $(DEFINES))
 CPPFLAGS += $(CPPFLAGS_NO_ARCH) $(ARCH_FLAGS)
@@ -404,7 +404,7 @@ SHARED_EXT_CORE = dll
 SHARED_EXT_CPP = dll
 
 SHARED_PREFIX =
-SHARED_VERSION_CORE = -51
+SHARED_VERSION_CORE = -52
 SHARED_VERSION_CPP = -1
 else ifeq ($(SYSTEM),Darwin)
 EXECUTABLE_SUFFIX =
@@ -690,6 +690,7 @@ LIBGRPC_SRC = \
     src/core/channelz/v2tov1/legacy_api.cc \
     src/core/channelz/v2tov1/property_list.cc \
     src/core/client_channel/backup_poller.cc \
+    src/core/client_channel/buffered_call.cc \
     src/core/client_channel/client_channel.cc \
     src/core/client_channel/client_channel_factory.cc \
     src/core/client_channel/client_channel_filter.cc \
@@ -807,6 +808,7 @@ LIBGRPC_SRC = \
     src/core/ext/transport/chttp2/transport/frame_security.cc \
     src/core/ext/transport/chttp2/transport/frame_settings.cc \
     src/core/ext/transport/chttp2/transport/frame_window_update.cc \
+    src/core/ext/transport/chttp2/transport/goaway.cc \
     src/core/ext/transport/chttp2/transport/hpack_encoder.cc \
     src/core/ext/transport/chttp2/transport/hpack_encoder_table.cc \
     src/core/ext/transport/chttp2/transport/hpack_parse_result.cc \
@@ -824,6 +826,7 @@ LIBGRPC_SRC = \
     src/core/ext/transport/chttp2/transport/ping_callbacks.cc \
     src/core/ext/transport/chttp2/transport/ping_promise.cc \
     src/core/ext/transport/chttp2/transport/ping_rate_policy.cc \
+    src/core/ext/transport/chttp2/transport/security_frame.cc \
     src/core/ext/transport/chttp2/transport/stream_lists.cc \
     src/core/ext/transport/chttp2/transport/transport_common.cc \
     src/core/ext/transport/chttp2/transport/varint.cc \
@@ -1328,6 +1331,7 @@ LIBGRPC_SRC = \
     src/core/lib/resource_quota/memory_quota.cc \
     src/core/lib/resource_quota/periodic_update.cc \
     src/core/lib/resource_quota/resource_quota.cc \
+    src/core/lib/resource_quota/stream_quota.cc \
     src/core/lib/resource_quota/thread_quota.cc \
     src/core/lib/resource_tracker/resource_tracker.cc \
     src/core/lib/security/authorization/audit_logging.cc \
@@ -1828,11 +1832,13 @@ PUBLIC_HEADERS_C += \
     include/grpc/grpc_posix.h \
     include/grpc/grpc_security.h \
     include/grpc/grpc_security_constants.h \
+    include/grpc/impl/call.h \
     include/grpc/impl/channel_arg_names.h \
     include/grpc/impl/codegen/byte_buffer.h \
     include/grpc/impl/codegen/byte_buffer_reader.h \
     include/grpc/impl/codegen/compression_types.h \
     include/grpc/impl/codegen/connectivity_state.h \
+    include/grpc/impl/codegen/fork.h \
     include/grpc/impl/codegen/grpc_types.h \
     include/grpc/impl/codegen/propagation_bits.h \
     include/grpc/impl/codegen/slice.h \
@@ -1885,8 +1891,8 @@ $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE): $(LIBGRPC_
 ifeq ($(SYSTEM),Darwin)
 	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -install_name $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) -dynamiclib -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
 else
-	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.51 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
-	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.51
+	$(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.52 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS)
+	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.52
 	$(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so
 endif
 endif

data/include/grpc/credentials.h

@@ -19,9 +19,12 @@
 #ifndef GRPC_CREDENTIALS_H
 #define GRPC_CREDENTIALS_H
 
-#include <grpc/grpc.h>
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/port_platform.h>
+#include <grpc/support/time.h>
 #include <stdbool.h>
 
 #ifdef __cplusplus
@@ -34,6 +37,8 @@ extern "C" {
    call. These credentials can be composed with a channel credentials object
    so that they are sent with every call on this channel.  */
 
+typedef struct grpc_server_credentials grpc_server_credentials;
+typedef struct grpc_channel_credentials grpc_channel_credentials;
 typedef struct grpc_call_credentials grpc_call_credentials;
 typedef struct grpc_auth_context grpc_auth_context;
 

data/include/grpc/event_engine/memory_allocator.h

@@ -50,6 +50,8 @@ class MemoryAllocator {
   MemoryAllocator(MemoryAllocator&&) = default;
   MemoryAllocator& operator=(MemoryAllocator&&) = default;
 
+  bool IsValid() const { return allocator_ != nullptr; }
+
   /// Drop the underlying allocator and make this an empty object.
   /// The object will not be usable after this call unless it's a valid
   /// allocator is moved into it.

data/include/grpc/impl/channel_arg_names.h

@@ -384,6 +384,11 @@
  *  Note that this works only with the "ares" DNS resolver; it isn't supported
  *  by the "native" DNS resolver. Boolean valued. Defaults to false. */
 #define GRPC_ARG_DNS_ENABLE_SRV_QUERIES "grpc.dns_enable_srv_queries"
+/** The cap for max_connections_per_subchannel when set via service
+ *  config.  If the configured value is higher than this, it will be
+ *  capped at this value.  Defaults to 10. */
+#define GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP \
+  "grpc.max_connections_per_subchannel_cap"
 /** If set, determines an upper bound on the number of milliseconds that the
  * c-ares based DNS resolver will wait on queries before cancelling them.
  * The default value is 120,000ms. Setting this to "0" will disable the

data/include/grpc/support/metrics.h

@@ -15,11 +15,17 @@
 #ifndef GRPC_SUPPORT_METRICS_H
 #define GRPC_SUPPORT_METRICS_H
 
-#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/string_view.h"
 
+// Forward declaration for EndpointConfig
+namespace grpc_event_engine {
+namespace experimental {
+class EndpointConfig;  // Forward declaration
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
 namespace grpc_core {
 namespace experimental {
 

data/src/core/call/call_filters.cc

@@ -16,10 +16,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/log.h"
 #include "src/core/call/metadata.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 // Call data for those calls that don't have any call data

data/src/core/call/call_filters.h

@@ -26,6 +26,7 @@
 #include "src/core/call/call_state.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -53,6 +54,7 @@
 // - OnClientToServerHalfClose - no value
 // - OnServerTrailingMetadata - $VALUE_TYPE = ServerMetadata
 // - OnFinalize               - special, see below
+// - ChannelzProperties       - special, see below
 // These members define an interception point for a particular event in
 // the call lifecycle.
 //
@@ -89,7 +91,7 @@
 // It's also acceptable to return a promise that resolves to the
 // relevant return type listed above.
 //
-// Finally, OnFinalize is added to intecept call finalization.
+// OnFinalize is added to intecept call finalization.
 // It must have one of the signatures:
 // - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
@@ -98,6 +100,11 @@
 // - void OnFinalize(const grpc_call_final_info*, FilterType*):
 //   the filter intercepts call finalization.
 //
+// ChannelzProperties is added to provide channelz data.
+// It must have one of the signatures:
+// - channelz::PropertyList ChannelzProperties();
+// - channelz::PropertyList ChannelzProperties(FilterType*);
+//
 // The constructor of the Call object can either take a pointer to the channel
 // object, or not take any arguments.
 //
@@ -1042,6 +1049,14 @@ struct ChannelDataDestructor {
   void* channel_data;
 };
 
+struct FilterMetadata {
+  absl::string_view name;
+  void* channel_data;
+  size_t call_data_offset;
+  channelz::PropertyList (*channelz_properties)(void* channel_data,
+                                                void* call_data);
+};
+
 // StackData contains the main datastructures built up by this module.
 // It's a complete representation of all the code that needs to be invoked
 // to execute a call for a given set of filters.
@@ -1071,6 +1086,79 @@ struct StackData {
   // A list of functions to call when this stack data is destroyed
   // (to capture ownership of channel data)
   std::vector<ChannelDataDestructor> channel_data_destructors;
+  // A list of metadata about filters for this stack.
+  std::vector<FilterMetadata> filter_metadata;
+
+  channelz::PropertyList ChannelzProperties(void* call_data) const {
+    absl::flat_hash_map<void*, const FilterMetadata*>
+        channel_data_to_filter_metadata;
+    for (const auto& filter_metadata : filter_metadata) {
+      channel_data_to_filter_metadata[filter_metadata.channel_data] =
+          &filter_metadata;
+    }
+    auto filter_chain =
+        [&channel_data_to_filter_metadata](const auto& container) {
+          std::vector<absl::string_view> filter_names;
+          for (const auto& filter : container) {
+            void* channel_data = filter.channel_data;
+            auto it = channel_data_to_filter_metadata.find(channel_data);
+            if (it != channel_data_to_filter_metadata.end()) {
+              filter_names.push_back(it->second->name);
+            } else {
+              filter_names.push_back("unknown_filter");
+            }
+          }
+          return absl::StrJoin(filter_names, ", ");
+        };
+    auto layout_properties = [&](const auto& layout) {
+      return channelz::PropertyList()
+          .Set("promise_size", layout.promise_size)
+          .Set("promise_alignment", layout.promise_alignment)
+          .Set("filters", filter_chain(layout.ops));
+    };
+    return channelz::PropertyList()
+        .Set("call_data_alignment", call_data_alignment)
+        .Set("call_data_size", call_data_size)
+        .Set("filters",
+             [&, this]() {
+               channelz::PropertyTable table;
+               for (const auto& filter : filter_metadata) {
+                 table.AppendRow(
+                     channelz::PropertyList()
+                         .Set("name", filter.name)
+                         .Set("call_data_offset", filter.call_data_offset)
+                         .Merge([&]() {
+                           if (call_data == nullptr) {
+                             return channelz::PropertyList();
+                           }
+                           if (filter.channelz_properties == nullptr) {
+                             return channelz::PropertyList();
+                           }
+                           return filter.channelz_properties(
+                               filter.channel_data,
+                               Offset(call_data, filter.call_data_offset));
+                         }()));
+               }
+               return table;
+             }())
+        .Set("constructors", filter_chain(filter_constructor))
+        // TODO(ctiller): Add the list of destructors (need to figure out how to
+        // map them).
+        .Set("client_initial_metadata",
+             layout_properties(client_initial_metadata))
+        .Set("server_initial_metadata",
+             layout_properties(server_initial_metadata))
+        .Set("client_to_server_messages",
+             layout_properties(client_to_server_messages))
+        .Set("client_to_server_half_close",
+             filter_chain(client_to_server_half_close))
+        .Set("server_to_client_messages",
+             layout_properties(server_to_client_messages))
+        .Set("server_trailing_metadata", filter_chain(server_trailing_metadata))
+        .Set("finalizers", filter_chain(finalizers))
+        .Set("channel_data_destructors",
+             filter_chain(channel_data_destructors));
+  }
 
   bool empty() const {
     return filter_constructor.empty() && filter_destructor.empty() &&
@@ -1253,6 +1341,69 @@ struct StackData {
         },
     });
   }
+
+  template <typename FilterType>
+  void AddFilterMetadata(FilterType* channel_data, size_t call_offset,
+                         channelz::PropertyList (FilterType::Call::*p)()
+                             const) {
+    GRPC_DCHECK(p == &FilterType::Call::ChannelzProperties);
+    filter_metadata.push_back(FilterMetadata{
+        TypeName<FilterType>(),
+        channel_data,
+        call_offset,
+        [](void* /*channel_data*/, void* call_data) {
+          return static_cast<typename FilterType::Call*>(call_data)
+              ->ChannelzProperties();
+        },
+    });
+  }
+
+  template <typename FilterType>
+  void AddFilterMetadata(FilterType* channel_data, size_t call_offset,
+                         channelz::PropertyList (FilterType::Call::*p)()) {
+    GRPC_DCHECK(p == &FilterType::Call::ChannelzProperties);
+    filter_metadata.push_back(FilterMetadata{
+        TypeName<FilterType>(),
+        channel_data,
+        call_offset,
+        [](void* /*channel_data*/, void* call_data) {
+          return static_cast<typename FilterType::Call*>(call_data)
+              ->ChannelzProperties();
+        },
+    });
+  }
+
+  template <typename FilterType>
+  void AddFilterMetadata(
+      FilterType* channel_data, size_t call_offset,
+      channelz::PropertyList (FilterType::Call::*p)(FilterType*) const) {
+    GRPC_DCHECK(p == &FilterType::Call::ChannelzProperties);
+    filter_metadata.push_back(FilterMetadata{
+        TypeName<FilterType>(),
+        channel_data,
+        call_offset,
+        [](void* channel_data, void* call_data) {
+          return static_cast<typename FilterType::Call*>(call_data)
+              ->ChannelzProperties(static_cast<FilterType*>(channel_data));
+        },
+    });
+  }
+
+  template <typename FilterType>
+  void AddFilterMetadata(
+      FilterType* channel_data, size_t call_offset,
+      channelz::PropertyList (FilterType::Call::*p)(FilterType*)) {
+    GRPC_DCHECK(p == &FilterType::Call::ChannelzProperties);
+    filter_metadata.push_back(FilterMetadata{
+        TypeName<FilterType>(),
+        channel_data,
+        call_offset,
+        [](void* channel_data, void* call_data) {
+          return static_cast<typename FilterType::Call*>(call_data)
+              ->ChannelzProperties(static_cast<FilterType*>(channel_data));
+        },
+    });
+  }
 };
 
 // OperationExecutor is a helper class to execute a sequence of operations
@@ -1400,6 +1551,9 @@ class ServerTrailingMetadataInterceptor {
                                   ServerTrailingMetadataInterceptor* filter) {
       filter->fn_(md);
     }
+    channelz::PropertyList ChannelzProperties() {
+      return channelz::PropertyList();
+    }
   };
 
   explicit ServerTrailingMetadataInterceptor(Fn fn) : fn_(std::move(fn)) {}
@@ -1423,6 +1577,10 @@ class ClientInitialMetadataInterceptor {
     static const inline NoInterceptor OnServerToClientMessage;
     static const inline NoInterceptor OnServerTrailingMetadata;
     static const inline NoInterceptor OnFinalize;
+
+    channelz::PropertyList ChannelzProperties() {
+      return channelz::PropertyList();
+    }
   };
 
   explicit ClientInitialMetadataInterceptor(Fn fn) : fn_(std::move(fn)) {}
@@ -1577,6 +1735,8 @@ class CallFilters {
       data_.AddServerToClientMessageOp(filter, call_offset);
       data_.AddServerTrailingMetadataOp(filter, call_offset);
       data_.AddFinalizer(filter, call_offset, &FilterType::Call::OnFinalize);
+      data_.AddFilterMetadata(filter, call_offset,
+                              &FilterType::Call::ChannelzProperties);
     }
 
     void AddOwnedObject(void (*destroy)(void* p), void* p) {
@@ -1646,6 +1806,20 @@ class CallFilters {
     return push_client_initial_metadata_.get();
   }
 
+  channelz::PropertyTable ChannelzProperties() {
+    channelz::PropertyTable properties;
+    for (size_t i = 0; i < stacks_.size(); ++i) {
+      void* stack_call_offset =
+          filters_detail::Offset(call_data_, stacks_[i].call_data_offset);
+      properties.AppendRow(
+          channelz::PropertyList()
+              .Set("call_data_offset", stacks_[i].call_data_offset)
+              .Merge(stacks_[i].stack->data_.ChannelzProperties(
+                  stack_call_offset)));
+    }
+    return properties;
+  }
+
  private:
   template <typename Output, typename Input,
             Input(CallFilters::* input_location),

data/src/core/call/call_spine.cc

@@ -16,10 +16,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/functional/any_invocable.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "absl/functional/any_invocable.h"
 
 namespace grpc_core {
 

data/src/core/call/call_spine.h

@@ -19,8 +19,10 @@
 
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/call/call_filters.h"
+#include "src/core/call/channelz_context.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -39,7 +41,7 @@ namespace grpc_core {
 // CallInitiator and CallHandler - which provide interfaces that are appropriate
 // for each side of a call.
 // Hosts context, call filters, and the arena.
-class CallSpine final : public Party {
+class CallSpine final : public Party, public channelz::DataSource {
  public:
   static RefCountedPtr<CallSpine> Create(
       ClientMetadataHandle client_initial_metadata,
@@ -49,7 +51,10 @@ class CallSpine final : public Party {
         std::move(client_initial_metadata), std::move(arena)));
   }
 
-  ~CallSpine() override { CallOnDone(true); }
+  ~CallSpine() override {
+    CallOnDone(true);
+    SourceDestructing();
+  }
 
   CallFilters& call_filters() { return call_filters_; }
 
@@ -285,12 +290,29 @@ class CallSpine final : public Party {
     }
   }
 
+  void AddData(channelz::DataSink sink) override {
+    this->ExportToChannelz(
+        "call_spine", sink, [self = RefAsSubclass<CallSpine>()]() {
+          return channelz::PropertyList()
+              .Set("filters", self->call_filters_.ChannelzProperties())
+              .Set("child_calls", self->child_calls_.size())
+              .Set("has_on_done", self->on_done_ != nullptr);
+        });
+  }
+
  private:
   friend class Arena;
   CallSpine(ClientMetadataHandle client_initial_metadata,
-            RefCountedPtr<Arena> arena)
-      : Party(std::move(arena)),
-        call_filters_(std::move(client_initial_metadata)) {}
+            RefCountedPtr<Arena> a)
+      : Party(std::move(a)),
+        channelz::DataSource([this]() -> RefCountedPtr<channelz::BaseNode> {
+          auto* p = arena()->GetContext<channelz::CallNode>();
+          if (p == nullptr) return nullptr;
+          return p->Ref();
+        }()),
+        call_filters_(std::move(client_initial_metadata)) {
+    SourceConstructed();
+  }
 
   SpawnSerializer* client_to_server_serializer() {
     if (client_to_server_serializer_ == nullptr) {

data/src/core/call/channelz_context.h

@@ -0,0 +1,30 @@
+// Copyright 2025 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_CALL_CHANNELZ_CONTEXT_H
+#define GRPC_SRC_CORE_CALL_CHANNELZ_CONTEXT_H
+
+#include "src/core/channelz/channelz.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+template <>
+struct ArenaContextType<channelz::CallNode> {
+  static void Destroy(channelz::CallNode*) {}
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CALL_CHANNELZ_CONTEXT_H

data/src/core/call/client_call.cc

@@ -39,8 +39,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/all_ok.h"
@@ -57,6 +55,8 @@
 #include "src/core/util/latent_see.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -105,7 +105,7 @@ ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
                        grpc_compression_options compression_options,
                        RefCountedPtr<Arena> arena,
                        RefCountedPtr<UnstartedCallDestination> destination)
-    : Call(false, deadline, std::move(arena)),
+    : Call(/*is_client=*/true, deadline, std::move(arena)),
       DualRefCounted("ClientCall"),
       cq_(cq),
       call_destination_(std::move(destination)),
@@ -120,8 +120,37 @@ ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
       reinterpret_cast<void*>(static_cast<uintptr_t>(registered_method)));
   if (deadline != Timestamp::InfFuture()) {
     send_initial_metadata_->Set(GrpcTimeoutMetadata(), deadline);
-    UpdateDeadline(deadline);
+    UpdateDeadline(deadline).IgnoreError();
   }
+  SourceConstructed();
+}
+
+void ClientCall::AddData(channelz::DataSink sink) {
+  Call::AddData(sink);
+  sink.AddData(
+      "client_call",
+      channelz::PropertyList()
+          .Set("call_state",
+               [this]() {
+                 switch (call_state_.load(std::memory_order_relaxed)) {
+                   case kUnstarted:
+                     return "Unstarted";
+                   case kStarted:
+                     return "Started";
+                   case kCancelled:
+                     return "Cancelled";
+                   default:
+                     return "StartedWithoutInitialMetadata";
+                 }
+               }())
+          .Set("cancel_status",
+               [this]() -> std::string {
+                 auto* p = cancel_status_.Get();
+                 if (p == nullptr) return "not cancelled";
+                 return p->ToString();
+               }())
+          .Set("saw_trailing_metadata",
+               saw_trailing_metadata_.load(std::memory_order_relaxed)));
 }
 
 grpc_call_error ClientCall::StartBatch(const grpc_op* ops, size_t nops,
@@ -228,11 +257,20 @@ Party::WakeupHold ClientCall::StartCall(
     const grpc_op& send_initial_metadata_op) {
   GRPC_LATENT_SEE_SCOPE("ClientCall::StartCall");
   auto cur_state = call_state_.load(std::memory_order_acquire);
+  // TODO(akshitpatel): [PH2][P3]: Might need to invoke
+  // PrepareApplicationMetadata here.
   CToMetadata(send_initial_metadata_op.data.send_initial_metadata.metadata,
               send_initial_metadata_op.data.send_initial_metadata.count,
               send_initial_metadata_.get());
   PrepareOutgoingInitialMetadata(send_initial_metadata_op,
                                  *send_initial_metadata_);
+  send_initial_metadata_->Set(
+      WaitForReady(),
+      WaitForReady::ValueType{
+          (send_initial_metadata_op.flags &
+           GRPC_INITIAL_METADATA_WAIT_FOR_READY) != 0,
+          (send_initial_metadata_op.flags &
+           GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET) != 0});
   auto call = MakeCallPair(std::move(send_initial_metadata_), arena()->Ref());
   started_call_initiator_ = std::move(call.initiator);
   Party::WakeupHold wakeup_hold{started_call_initiator_.party()};
@@ -264,7 +302,7 @@ bool ClientCall::StartCallMaybeUpdateState(uintptr_t& cur_state,
                                               std::memory_order_acquire)) {
         call_destination_->StartCall(std::move(handler));
         auto unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
-        while (unordered_start->next != nullptr) {
+        while (unordered_start != nullptr) {
           unordered_start->start_pending_batch();
           auto next = unordered_start->next;
           delete unordered_start;

data/src/core/call/client_call.h

@@ -37,9 +37,6 @@
 #include <cstdint>
 #include <string>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -49,6 +46,9 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/single_set_ptr.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -78,6 +78,7 @@ class ClientCall final
   void InternalUnref(const char*) override { WeakUnref(); }
 
   void Orphaned() override {
+    SourceDestructing();
     if (!saw_trailing_metadata_.load(std::memory_order_relaxed)) {
       CancelWithError(absl::CancelledError());
     }
@@ -118,6 +119,8 @@ class ClientCall final
     this->~ClientCall();
   }
 
+  void AddData(channelz::DataSink sink) override;
+
  private:
   struct UnorderedStart {
     absl::AnyInvocable<void()> start_pending_batch;