grpc 1.75.0 → 1.78.0

data/src/core/channelz/channelz_registry.h

@@ -21,16 +21,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <map>
 #include <string>
 
-#include "absl/container/btree_map.h"
-#include "absl/functional/function_ref.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "absl/container/btree_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/function_ref.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -115,6 +117,11 @@ class ChannelzRegistry final {
                                                 max_results);
   }
 
+  static std::vector<WeakRefCountedPtr<BaseNode>> GetDescendants(
+      BaseNode* root, size_t max_results) {
+    return Default()->InternalGetDescendants(root, max_results);
+  }
+
   static WeakRefCountedPtr<BaseNode> GetNode(intptr_t uuid) {
     return Default()->InternalGet(uuid);
   }
@@ -125,6 +132,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 +257,45 @@ class ChannelzRegistry final {
         max_results);
   }
 
+  std::vector<WeakRefCountedPtr<BaseNode>> InternalGetDescendants(
+      BaseNode* root, size_t max_results) {
+    std::vector<WeakRefCountedPtr<BaseNode>> descendants;
+    if (root == nullptr || max_results == 0) return descendants;
+
+    // To prevent duplicate nodes and to prevent infinite loops.
+    absl::flat_hash_set<intptr_t> visited;
+
+    descendants.reserve(max_results);
+    visited.insert(root->uuid());
+    descendants.push_back(root->WeakRef());
+
+    size_t next_id = 0;
+
+    // BFS to find all descendants.
+    do {
+      BaseNode* current_node = descendants[next_id].get();
+
+      auto [children, _] = InternalGetChildren(
+          current_node, current_node->uuid(), max_results - descendants.size());
+
+      for (const auto& child : children) {
+        if (visited.insert(child->uuid()).second) {
+          descendants.push_back(child);
+        }
+      }
+
+      ++next_id;
+    } while (descendants.size() < max_results && next_id < descendants.size());
+
+    return descendants;
+  }
+
+  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

@@ -20,9 +20,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "google/protobuf/any.upb.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/string.h"
@@ -32,6 +29,10 @@
 #include "src/proto/grpc/channelz/v2/property_list.upb.h"
 #include "upb/mem/arena.h"
 #include "upb/text/encode.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
 
 namespace grpc_core::channelz {
 
@@ -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>>> {
@@ -130,6 +139,8 @@ class PropertyList final : public OtherPropertyValue {
 
   PropertyList& Merge(PropertyList other);
 
+  bool empty() const { return property_list_.empty(); }
+
   // TODO(ctiller): remove soon, switch to just FillUpbProto.
   Json::Object TakeJsonObject() override;
   void FillUpbProto(grpc_channelz_v2_PropertyList* proto, upb_Arena* arena);

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

@@ -18,12 +18,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/cleanup/cleanup.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/strip.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
@@ -43,6 +37,12 @@
 #include "upb/json/encode.h"
 #include "upb/mem/arena.hpp"
 #include "upb/reflection/def.hpp"
+#include "absl/cleanup/cleanup.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -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

@@ -14,15 +14,11 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include <string>
 #include <vector>
 
-#include "absl/log/log.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/channelz/channelz_registry.h"
 #include "src/core/channelz/v2tov1/convert.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -30,6 +26,10 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
+#include "absl/log/log.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
 
 // This file is a temporary compatibility layer between the v2 channelz data
 // model and the v1 C-API. It should be removed when the v1 C-API is removed.
@@ -46,7 +46,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 +62,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 +139,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 +178,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 +214,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 +300,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 +342,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 +384,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,

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

@@ -15,16 +15,17 @@
 #include "src/core/channelz/v2tov1/property_list.h"
 
 #include <cstdint>
+#include <limits>
 #include <optional>
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
 #include "src/core/util/upb_utils.h"
 #include "src/proto/grpc/channelz/v2/property_list.upb.h"
 #include "upb/mem/arena.hpp"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 namespace channelz {