grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/call/filter_fusion.h

@@ -23,7 +23,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
@@ -35,6 +34,7 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/type_list.h"
@@ -1021,14 +1021,14 @@ struct FilterWrapper<Typelist<Filter>> {
 
   absl::Status status() const { return filter_.status(); }
   bool StartTransportOp(grpc_transport_op* op) {
-    CHECK(filter_.ok());
+    GRPC_CHECK(filter_.ok());
     return (*filter_)->StartTransportOp(op);
   }
 
   Filter* get_filter() { return (*filter_).get(); }
 
   bool GetChannelInfo(const grpc_channel_info* info) {
-    CHECK(filter_.ok());
+    GRPC_CHECK(filter_.ok());
     return (*filter_)->GetChannelInfo(info);
   }
 
@@ -1053,13 +1053,13 @@ struct FilterWrapper<Typelist<Filter0, Filters...>>
   Filter0* get_filter() { return (*filter0_).get(); }
 
   bool StartTransportOp(grpc_transport_op* op) {
-    CHECK(filter0_.ok());
+    GRPC_CHECK(filter0_.ok());
     return (*filter0_)->StartTransportOp(op) ||
            FilterWrapper<Typelist<Filters...>>::StartTransportOp(op);
   }
 
   bool GetChannelInfo(const grpc_channel_info* info) {
-    CHECK(filter0_.ok());
+    GRPC_CHECK(filter0_.ok());
     return (*filter0_)->GetChannelInfo(info) ||
            FilterWrapper<Typelist<Filters...>>::GetChannelInfo(info);
   }

data/src/core/call/metadata_batch.h

@@ -32,7 +32,6 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/function_ref.h"
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
@@ -45,6 +44,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/chunked_vector.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/if_list.h"
 #include "src/core/util/packed_table.h"
 #include "src/core/util/time.h"
@@ -107,7 +107,7 @@ struct TeMetadata {
                                   MetadataParseErrorFn on_error);
   static ValueType MementoToValue(MementoType te) { return te; }
   static StaticSlice Encode(ValueType x) {
-    CHECK(x == kTrailers);
+    GRPC_CHECK(x == kTrailers);
     return StaticSlice::FromStaticString("trailers");
   }
   static const char* DisplayValue(ValueType te);
@@ -213,7 +213,7 @@ struct CompressionAlgorithmBasedMetadata {
                                   MetadataParseErrorFn on_error);
   static ValueType MementoToValue(MementoType x) { return x; }
   static Slice Encode(ValueType x) {
-    CHECK(x != GRPC_COMPRESS_ALGORITHMS_COUNT);
+    GRPC_CHECK(x != GRPC_COMPRESS_ALGORITHMS_COUNT);
     return Slice::FromStaticString(CompressionAlgorithmAsString(x));
   }
   static const char* DisplayValue(ValueType x) {

data/src/core/call/security_context.cc

@@ -25,7 +25,6 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/credentials/call/call_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -33,6 +32,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 // --- grpc_call ---

data/src/core/call/server_call.cc

@@ -37,7 +37,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
@@ -51,6 +50,7 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/util/bitset.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 
 namespace grpc_core {
@@ -169,12 +169,12 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
       // after passing it in, which shouldn't be a supported API.
       metadata->Set(GrpcMessageMetadata(), Slice(grpc_slice_copy(*details)));
     }
-    CHECK(metadata != nullptr);
+    GRPC_CHECK(metadata != nullptr);
     bool wait_for_initial_metadata_scheduled =
         sent_server_initial_metadata_batch_.load(std::memory_order_relaxed);
     return [this, metadata = std::move(metadata),
             wait_for_initial_metadata_scheduled]() mutable {
-      CHECK(metadata != nullptr);
+      GRPC_CHECK(metadata != nullptr);
       // If there was a send initial metadata batch sent prior to this one, then
       // make sure it's been scheduled first - otherwise we may accidentally
       // treat this as trailers only.
@@ -184,7 +184,7 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
               [this]() { return server_initial_metadata_scheduled_.Wait(); },
               []() { return Empty{}; }),
           [this, metadata = std::move(metadata)]() mutable -> Poll<Success> {
-            CHECK(metadata != nullptr);
+            GRPC_CHECK(metadata != nullptr);
             call_handler_.PushServerTrailingMetadata(std::move(metadata));
             return Success{};
           });

data/src/core/call/server_call.h

@@ -39,7 +39,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -53,6 +52,7 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 

data/src/core/channelz/channelz.cc

@@ -138,20 +138,14 @@ Json::Object BaseNode::AdditionalInfo() {
   return sink_impl->Finalize(!completed);
 }
 
-void BaseNode::RunZTrace(
-    absl::string_view name, Timestamp deadline,
-    std::map<std::string, std::string> args,
+std::unique_ptr<ZTrace> BaseNode::RunZTrace(
+    absl::string_view name, ZTrace::Args args,
     std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine,
-    absl::AnyInvocable<void(Json)> callback) {
-  // Limit deadline to help contain potential resource exhaustion due to
-  // tracing.
-  deadline = std::min(deadline, Timestamp::Now() + Duration::Minutes(10));
+    ZTrace::Callback callback) {
   auto fail = [&callback, event_engine](absl::Status status) {
     event_engine->Run(
         [callback = std::move(callback), status = std::move(status)]() mutable {
-          Json::Object object;
-          object["status"] = Json::FromString(status.ToString());
-          callback(Json::FromObject(std::move(object)));
+          callback(status);
         });
   };
   std::unique_ptr<ZTrace> ztrace;
@@ -165,20 +159,21 @@ void BaseNode::RunZTrace(
         } else {
           fail(absl::InternalError(
               absl::StrCat("Ambiguous ztrace handler: ", name)));
-          return;
+          return nullptr;
         }
       }
     }
   }
   if (ztrace == nullptr) {
     fail(absl::NotFoundError(absl::StrCat("ztrace not found: ", name)));
-    return;
+    return nullptr;
   }
-  ztrace->Run(deadline, std::move(args), event_engine, std::move(callback));
+  ztrace->Run(std::move(args), event_engine, std::move(callback));
+  return ztrace;
 }
 
 void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
-                               upb_Arena* arena) {
+                               upb_Arena* arena, absl::Duration timeout) {
   grpc_channelz_v2_Entity_set_id(entity, uuid());
   grpc_channelz_v2_Entity_set_kind(
       entity, StdStringToUpbString(EntityTypeToKind(type_)));
@@ -208,8 +203,7 @@ void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
   }
   make_data_sink().AddData("v1_compatibility",
                            PropertyList().Set("name", name()));
-  bool completed =
-      done->WaitForNotificationWithTimeout(absl::Milliseconds(100));
+  bool completed = done->WaitForNotificationWithTimeout(timeout);
   sink_impl->Finalize(!completed, entity, arena);
 
   trace_.Render(entity, arena);
@@ -219,11 +213,11 @@ void BaseNode::AddNodeSpecificData(DataSink) {
   // Default implementation does nothing.
 }
 
-std::string BaseNode::SerializeEntityToString() {
+std::string BaseNode::SerializeEntityToString(absl::Duration timeout) {
   upb_Arena* arena = upb_Arena_New();
   auto cleanup = absl::MakeCleanup([arena]() { upb_Arena_Free(arena); });
   grpc_channelz_v2_Entity* entity = grpc_channelz_v2_Entity_new(arena);
-  SerializeEntity(entity, arena);
+  SerializeEntity(entity, arena, timeout);
   size_t length;
   auto* bytes = grpc_channelz_v2_Entity_serialize(entity, arena, &length);
   return std::string(bytes, length);

data/src/core/channelz/channelz.h

@@ -52,6 +52,7 @@
 #include "src/core/util/time_precise.h"
 #include "src/core/util/useful.h"
 #include "src/proto/grpc/channelz/v2/channelz.upb.h"
+#include "src/proto/grpc/channelz/v2/service.upb.h"
 
 // Channel arg key for channelz node.
 #define GRPC_ARG_CHANNELZ_CHANNEL_NODE \
@@ -91,6 +92,29 @@ class CallCountingHelperPeer;
 class SubchannelNodePeer;
 }  // namespace testing
 
+class ZTrace {
+ public:
+  virtual ~ZTrace() = default;
+
+  using Args = std::map<std::string, std::variant<int64_t, std::string, bool>>;
+  // Callback is called periodically with the latest results from the ztrace.
+  // The format is a StatusOr<optional<string>>.
+  // - If the status is not-OK, then the ztrace encountered an error and this
+  //   will be the last callback.
+  // - If the status is OK but the optional<string> is empty, then the ztrace is
+  //   completed (successfully).
+  // - If the status is OK and the optional<string> is non-empty, then the
+  //   ztrace is still running and the string is the latest output - a
+  //   serialized QueryTraceResponse proto.
+  using Callback =
+      absl::AnyInvocable<void(absl::StatusOr<std::optional<std::string>>)>;
+
+  virtual void Run(Args args,
+                   std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+                       event_engine,
+                   Callback callback) = 0;
+};
+
 // base class for all channelz entities
 class BaseNode : public DualRefCounted<BaseNode> {
  public:
@@ -210,11 +234,11 @@ class BaseNode : public DualRefCounted<BaseNode> {
   }
   const std::string& name() const { return name_; }
 
-  void RunZTrace(absl::string_view name, Timestamp deadline,
-                 std::map<std::string, std::string> args,
-                 std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-                     event_engine,
-                 absl::AnyInvocable<void(Json output)> callback);
+  std::unique_ptr<ZTrace> RunZTrace(
+      absl::string_view name, ZTrace::Args args,
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine,
+      ZTrace::Callback callback);
   Json::Object AdditionalInfo();
 
   const ChannelTrace& trace() const { return trace_; }
@@ -224,9 +248,10 @@ class BaseNode : public DualRefCounted<BaseNode> {
   }
   ChannelTrace& mutable_trace() { return trace_; }
 
-  void SerializeEntity(grpc_channelz_v2_Entity* entity, upb_Arena* arena);
+  void SerializeEntity(grpc_channelz_v2_Entity* entity, upb_Arena* arena,
+                       absl::Duration timeout);
 
-  std::string SerializeEntityToString();
+  std::string SerializeEntityToString(absl::Duration timeout);
 
  protected:
   void PopulateJsonFromDataSources(Json::Object& json);
@@ -276,15 +301,6 @@ LogOutputFrom(const RefCountedPtr<N>& n) {
 }
 }  // namespace detail
 
-class ZTrace {
- public:
-  virtual ~ZTrace() = default;
-  virtual void Run(Timestamp deadline, std::map<std::string, std::string> args,
-                   std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-                       event_engine,
-                   absl::AnyInvocable<void(Json)>) = 0;
-};
-
 // This class is used to collect additional information about the channelz
 // node. It's the backing implementation for DataSink. channelz users should
 // use DataSink instead of this class directly.

data/src/core/channelz/channelz_registry.h

@@ -125,6 +125,11 @@ class ChannelzRegistry final {
     return Default()->InternalGetNodesOfType(start_node, type, max_results);
   }
 
+  static std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool> GetNodes(
+      intptr_t start_node, size_t max_results) {
+    return Default()->InternalGetNodes(start_node, max_results);
+  }
+
   // Test only helper function to dump the JSON representation to std out.
   // This can aid in debugging channelz code.
   static void LogAllEntities() { Default()->InternalLogAllEntities(); }
@@ -245,6 +250,12 @@ class ChannelzRegistry final {
         max_results);
   }
 
+  std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool> InternalGetNodes(
+      intptr_t start_node, size_t max_results) {
+    return QueryNodes(
+        start_node, [](const BaseNode*) { return true; }, max_results);
+  }
+
   template <typename T, BaseNode::EntityType entity_type>
   WeakRefCountedPtr<T> InternalGetTyped(intptr_t uuid) {
     WeakRefCountedPtr<BaseNode> node = InternalGet(uuid);

data/src/core/channelz/property_list.cc

@@ -49,6 +49,14 @@ Json ToJson(const PropertyValue& value) {
         return Json::FromString(
             gpr_format_timespec(v.as_timespec(GPR_CLOCK_REALTIME)));
       },
+      [](absl::Time v) {
+        gpr_timespec ts;
+        ts.clock_type = GPR_CLOCK_REALTIME;
+        auto osts = absl::ToTimespec(v);
+        ts.tv_sec = osts.tv_sec;
+        ts.tv_nsec = osts.tv_nsec;
+        return Json::FromString(gpr_format_timespec(ts));
+      },
       [](absl::Status v) { return Json::FromString(v.ToString()); },
       [](std::shared_ptr<OtherPropertyValue> v) {
         return Json::FromObject(v->TakeJsonObject());
@@ -96,6 +104,16 @@ void FillUpbValue(const PropertyValue& value,
         grpc_channelz_v2_PropertyValue_set_timestamp_value(proto,
                                                            timestamp_proto);
       },
+      [proto, arena](absl::Time v) {
+        auto* timestamp_proto =
+            grpc_channelz_v2_PropertyValue_mutable_timestamp_value(proto,
+                                                                   arena);
+        auto ts = absl::ToTimespec(v);
+        google_protobuf_Timestamp_set_seconds(timestamp_proto, ts.tv_sec);
+        google_protobuf_Timestamp_set_nanos(timestamp_proto, ts.tv_nsec);
+        grpc_channelz_v2_PropertyValue_set_timestamp_value(proto,
+                                                           timestamp_proto);
+      },
       [proto, arena](absl::Status v) {
         std::string text = v.ToString();
         grpc_channelz_v2_PropertyValue_set_string_value(

data/src/core/channelz/property_list.h

@@ -23,6 +23,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/time/time.h"
 #include "google/protobuf/any.upb.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/string.h"
@@ -44,7 +45,7 @@ class OtherPropertyValue {
 
 using PropertyValue =
     std::variant<absl::string_view, std::string, int64_t, uint64_t, double,
-                 bool, Duration, Timestamp, absl::Status,
+                 bool, Duration, Timestamp, absl::Status, absl::Time,
                  std::shared_ptr<OtherPropertyValue>>;
 
 namespace property_list_detail {
@@ -64,6 +65,14 @@ struct Wrapper<
   }
 };
 
+template <typename T>
+struct Wrapper<absl::StatusOr<T>> {
+  static std::optional<PropertyValue> Wrap(absl::StatusOr<T> value) {
+    if (value.ok()) return Wrapper<T>::Wrap(*std::move(value));
+    return PropertyValue(std::move(value).status());
+  }
+};
+
 template <typename T>
 struct Wrapper<T,
                std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>>> {

data/src/core/channelz/text_encode.cc

@@ -0,0 +1,66 @@
+// 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.
+
+#include "src/core/channelz/text_encode.h"
+
+#include <string>
+
+#include "src/core/util/no_destruct.h"
+#include "src/proto/grpc/channelz/v2/channelz.upbdefs.h"
+#include "src/proto/grpc/channelz/v2/property_list.upbdefs.h"
+#include "src/proto/grpc/channelz/v2/service.upbdefs.h"
+#include "upb/mem/arena.h"
+#include "upb/reflection/def.hpp"
+#include "upb/text/encode.h"
+
+namespace grpc_core::channelz {
+
+namespace {
+
+upb_DefPool* DefPool() {
+  static NoDestruct<upb::DefPool> def_pool{[]() {
+    upb::DefPool pool;
+    grpc_channelz_v2_Entity_getmsgdef(pool.ptr());
+    grpc_channelz_v2_PropertyList_getmsgdef(pool.ptr());
+    grpc_channelz_v2_PropertyGrid_getmsgdef(pool.ptr());
+    grpc_channelz_v2_PropertyTable_getmsgdef(pool.ptr());
+    grpc_channelz_v2_QueryEntitiesRequest_getmsgdef(pool.ptr());
+    grpc_channelz_v2_QueryEntitiesResponse_getmsgdef(pool.ptr());
+    grpc_channelz_v2_GetEntityRequest_getmsgdef(pool.ptr());
+    grpc_channelz_v2_GetEntityResponse_getmsgdef(pool.ptr());
+    grpc_channelz_v2_QueryTraceRequest_getmsgdef(pool.ptr());
+    grpc_channelz_v2_QueryTraceResponse_getmsgdef(pool.ptr());
+    grpc_channelz_v2_TraceEvent_getmsgdef(pool.ptr());
+    return pool;
+  }()};
+  return def_pool->ptr();
+}
+
+}  // namespace
+
+std::string TextEncode(upb_Message* message,
+                       const upb_MessageDef* (*getmsgdef)(upb_DefPool*)) {
+  char buf[10240];
+  auto* def_pool = DefPool();
+  auto* def = getmsgdef(def_pool);
+  size_t size = upb_TextEncode(message, def, def_pool, 0, buf, sizeof(buf));
+  if (size < sizeof(buf)) return std::string(buf, size);
+  char* new_buf = new char[size];
+  upb_TextEncode(message, def, def_pool, 0, new_buf, size);
+  std::string result(new_buf, size);
+  delete[] new_buf;
+  return result;
+}
+
+}  // namespace grpc_core::channelz

data/src/core/channelz/text_encode.h

@@ -0,0 +1,29 @@
+// 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_CHANNELZ_TEXT_ENCODE_H
+#define GRPC_SRC_CORE_CHANNELZ_TEXT_ENCODE_H
+
+#include <string>
+
+#include "upb/text/encode.h"
+
+namespace grpc_core::channelz {
+
+std::string TextEncode(upb_Message* message,
+                       const upb_MessageDef* (*getmsgdef)(upb_DefPool*));
+
+}  // namespace grpc_core::channelz
+
+#endif  // GRPC_SRC_CORE_CHANNELZ_TEXT_ENCODE_H

data/src/core/channelz/v2tov1/convert.cc

@@ -155,6 +155,17 @@ grpc_channelz_v1_ChannelConnectivityState_State ConnectivityStateFromString(
 void PopulateV1Trace(const grpc_channelz_v2_TraceEvent* const* trace_events,
                      size_t num_events, upb_Arena* arena,
                      grpc_channelz_v1_ChannelTrace* trace) {
+  if (num_events > 0) {
+    const auto* ts = grpc_channelz_v2_TraceEvent_timestamp(trace_events[0]);
+    if (ts != nullptr) {
+      auto* v1_ts = grpc_channelz_v1_ChannelTrace_mutable_creation_timestamp(
+          trace, arena);
+      google_protobuf_Timestamp_set_seconds(
+          v1_ts, google_protobuf_Timestamp_seconds(ts));
+      google_protobuf_Timestamp_set_nanos(v1_ts,
+                                          google_protobuf_Timestamp_nanos(ts));
+    }
+  }
   for (size_t i = 0; i < num_events; ++i) {
     auto* v1_event = grpc_channelz_v1_ChannelTrace_add_events(trace, arena);
     upb_StringView description =

data/src/core/channelz/v2tov1/legacy_api.cc

@@ -23,6 +23,7 @@
 #include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
 #include "src/core/channelz/channelz_registry.h"
 #include "src/core/channelz/v2tov1/convert.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -46,7 +47,7 @@ class RegistryEntityFetcher : public EntityFetcher {
     if (node == nullptr) {
       return absl::NotFoundError(absl::StrCat("Entity not found: ", id));
     }
-    return node->SerializeEntityToString();
+    return node->SerializeEntityToString(absl::ZeroDuration());
   }
 
   absl::StatusOr<std::vector<std::string>> GetEntitiesWithParent(
@@ -62,7 +63,8 @@ class RegistryEntityFetcher : public EntityFetcher {
     std::vector<std::string> children_str;
     for (const auto& child_node : nodes) {
       if (child_node == nullptr) continue;
-      children_str.push_back(child_node->SerializeEntityToString());
+      children_str.push_back(
+          child_node->SerializeEntityToString(absl::ZeroDuration()));
     }
     return children_str;
   }
@@ -138,7 +140,8 @@ char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
     grpc_core::Json::Array array;
     for (const auto& channel_node : channels) {
       if (channel_node == nullptr) continue;
-      auto serialized_v2 = channel_node->SerializeEntityToString();
+      auto serialized_v2 =
+          channel_node->SerializeEntityToString(absl::ZeroDuration());
       auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertChannel(
           serialized_v2, fetcher, true);
       if (!serialized_v1.ok()) {
@@ -176,7 +179,8 @@ char* grpc_channelz_get_servers(intptr_t start_server_id) {
     grpc_core::Json::Array array;
     for (const auto& server_node : servers) {
       if (server_node == nullptr) continue;
-      auto serialized_v2 = server_node->SerializeEntityToString();
+      auto serialized_v2 =
+          server_node->SerializeEntityToString(absl::ZeroDuration());
       auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertServer(
           serialized_v2, fetcher, true);
       if (!serialized_v1.ok()) {
@@ -211,7 +215,8 @@ char* grpc_channelz_get_server(intptr_t server_id) {
     auto server_node = ChannelzRegistry::GetServer(server_id);
     if (server_node == nullptr) return nullptr;
     RegistryEntityFetcher fetcher;
-    auto serialized_v2 = server_node->SerializeEntityToString();
+    auto serialized_v2 =
+        server_node->SerializeEntityToString(absl::ZeroDuration());
     auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertServer(
         serialized_v2, fetcher, true);
     if (!serialized_v1.ok()) {
@@ -296,7 +301,8 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
     auto channel_node = ChannelzRegistry::GetChannel(channel_id);
     if (channel_node == nullptr) return nullptr;
     RegistryEntityFetcher fetcher;
-    auto serialized_v2 = channel_node->SerializeEntityToString();
+    auto serialized_v2 =
+        channel_node->SerializeEntityToString(absl::ZeroDuration());
     auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertChannel(
         serialized_v2, fetcher, true);
     if (!serialized_v1.ok()) {
@@ -337,7 +343,8 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
     auto subchannel_node = ChannelzRegistry::GetSubchannel(subchannel_id);
     if (subchannel_node == nullptr) return nullptr;
     RegistryEntityFetcher fetcher;
-    auto serialized_v2 = subchannel_node->SerializeEntityToString();
+    auto serialized_v2 =
+        subchannel_node->SerializeEntityToString(absl::ZeroDuration());
     auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertSubchannel(
         serialized_v2, fetcher, true);
     if (!serialized_v1.ok()) {
@@ -378,7 +385,7 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
     auto node = ChannelzRegistry::GetNode(socket_id);
     if (node == nullptr) return nullptr;
     RegistryEntityFetcher fetcher;
-    auto serialized_v2 = node->SerializeEntityToString();
+    auto serialized_v2 = node->SerializeEntityToString(absl::ZeroDuration());
     absl::StatusOr<std::string> serialized_v1;
     if (node->type() == grpc_core::channelz::BaseNode::EntityType::kSocket) {
       serialized_v1 = grpc_core::channelz::v2tov1::ConvertSocket(serialized_v2,