grpc 1.73.0 → 1.75.0

data/src/core/channelz/channelz.cc

@@ -30,22 +30,28 @@
 #include <string>
 #include <tuple>
 
+#include "absl/cleanup/cleanup.h"
 #include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 #include "src/core/channelz/channelz_registry.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/util/json/json_writer.h"
+#include "src/core/util/notification.h"
 #include "src/core/util/string.h"
 #include "src/core/util/time.h"
+#include "src/core/util/time_precise.h"
+#include "src/core/util/upb_utils.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/useful.h"
+#include "src/proto/grpc/channelz/v2/channelz.upb.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -54,123 +60,54 @@ namespace channelz {
 // DataSink
 //
 
-namespace {
-class ChildObjectCollector {
- public:
-  void Add(RefCountedPtr<BaseNode> node) {
-    child_objects_[node->type()].insert(node->uuid());
-  }
-
-  void Add(std::vector<RefCountedPtr<BaseNode>> nodes) {
-    for (auto& node : nodes) Add(std::move(node));
-  }
-
-  // Calls AddAdditionalInfo to export the collected child objects.
-  void Finalize(DataSink& sink) {
-    if (child_objects_.empty()) return;
-    Json::Object subobjects;
-    for (const auto& [type, child_objects] : child_objects_) {
-      std::string key;
-      switch (type) {
-        case BaseNode::EntityType::kTopLevelChannel:
-        case BaseNode::EntityType::kSubchannel:
-        case BaseNode::EntityType::kListenSocket:
-        case BaseNode::EntityType::kServer:
-        case BaseNode::EntityType::kInternalChannel: {
-          LOG(ERROR)
-              << "Nodes of type " << BaseNode::EntityTypeString(type)
-              << " not supported for child object collection in DataSink";
-          continue;
-        }
-        case BaseNode::EntityType::kSocket:
-          key = "subSockets";
-          break;
-        case BaseNode::EntityType::kCall:
-          key = "calls";
-          break;
-      }
-      Json::Array uuids;
-      uuids.reserve(child_objects.size());
-      for (int64_t uuid : child_objects) {
-        uuids.push_back(Json::FromNumber(uuid));
-      }
-      subobjects[key] = Json::FromArray(std::move(uuids));
-    }
-    sink.AddAdditionalInfo("childObjects", std::move(subobjects));
-  }
-
- private:
-  std::map<BaseNode::EntityType, std::set<int64_t>> child_objects_;
-};
-
-class JsonDataSink final : public DataSink {
- public:
-  explicit JsonDataSink(Json::Object& output) : output_(output) {
-    CHECK(output_.find("additionalInfo") == output_.end());
-  }
-  ~JsonDataSink() {
-    collector_.Finalize(*this);
-    if (additional_info_ != nullptr) {
-      output_["additionalInfo"] =
-          Json::FromObject(std::move(*additional_info_));
-    }
-  }
-
-  void AddAdditionalInfo(absl::string_view name,
-                         Json::Object additional_info) override {
-    if (additional_info_ == nullptr) {
-      additional_info_ = std::make_unique<Json::Object>();
-    }
-    additional_info_->emplace(name,
-                              Json::FromObject(std::move(additional_info)));
-  }
-
-  void AddChildObjects(
-      std::vector<RefCountedPtr<BaseNode>> child_objects) override {
-    collector_.Add(std::move(child_objects));
-  }
-
- private:
-  Json::Object& output_;
-  std::unique_ptr<Json::Object> additional_info_;
-  ChildObjectCollector collector_;
-};
-
-class ExplicitJsonDataSink final : public DataSink {
- public:
-  void AddAdditionalInfo(absl::string_view name,
-                         Json::Object additional_info) override {
-    additional_info_.emplace(name,
-                             Json::FromObject(std::move(additional_info)));
-  }
+void DataSinkImplementation::AddData(absl::string_view name,
+                                     std::unique_ptr<Data> data) {
+  MutexLock lock(&mu_);
+  additional_info_.emplace(name, std::move(data));
+}
 
-  void AddChildObjects(
-      std::vector<RefCountedPtr<BaseNode>> child_objects) override {
-    collector_.Add(std::move(child_objects));
+Json::Object DataSinkImplementation::Finalize(bool) {
+  MutexLock lock(&mu_);
+  Json::Object out;
+  for (auto& [name, additional_info] : additional_info_) {
+    out[name] = Json::FromObject(additional_info->ToJson());
   }
+  return out;
+}
 
-  Json::Object Finalize() {
-    collector_.Finalize(*this);
-    return std::move(additional_info_);
+void DataSinkImplementation::Finalize(bool timed_out,
+                                      grpc_channelz_v2_Entity* entity,
+                                      upb_Arena* arena) {
+  MutexLock lock(&mu_);
+  grpc_channelz_v2_Entity_set_timed_out(entity, timed_out);
+  for (auto& [name, additional_info] : additional_info_) {
+    auto* staple = grpc_channelz_v2_Entity_add_data(entity, arena);
+    grpc_channelz_v2_Data_set_name(staple,
+                                   CopyStdStringToUpbString(name, arena));
+    additional_info->FillProto(
+        grpc_channelz_v2_Data_mutable_value(staple, arena), arena);
   }
-
- private:
-  Json::Object additional_info_;
-  ChildObjectCollector collector_;
-};
-}  // namespace
+}
 
 //
 // BaseNode
 //
 
-BaseNode::BaseNode(EntityType type, std::string name)
-    : type_(type), uuid_(-1), name_(std::move(name)) {
-  // The registry will set uuid_ under its lock.
+BaseNode::BaseNode(EntityType type, size_t max_trace_memory, std::string name)
+    : type_(type),
+      uuid_(-1),
+      name_(std::move(name)),
+      trace_(max_trace_memory) {}
+
+void BaseNode::NodeConstructed() {
+  node_constructed_called_ = true;
   ChannelzRegistry::Register(this);
 }
 
-void BaseNode::Orphaned() { ChannelzRegistry::Unregister(this); }
+void BaseNode::Orphaned() {
+  DCHECK(node_constructed_called_);
+  ChannelzRegistry::Unregister(this);
+}
 
 intptr_t BaseNode::UuidSlow() { return ChannelzRegistry::NumberNode(this); }
 
@@ -180,20 +117,25 @@ std::string BaseNode::RenderJsonString() {
 }
 
 void BaseNode::PopulateJsonFromDataSources(Json::Object& json) {
-  JsonDataSink sink(json);
-  MutexLock lock(&data_sources_mu_);
-  for (DataSource* data_source : data_sources_) {
-    data_source->AddData(sink);
-  }
+  auto info = AdditionalInfo();
+  if (info.empty()) return;
+  json["additionalInfo"] = Json::FromObject(std::move(info));
 }
 
 Json::Object BaseNode::AdditionalInfo() {
-  ExplicitJsonDataSink sink;
-  MutexLock lock(&data_sources_mu_);
-  for (DataSource* data_source : data_sources_) {
-    data_source->AddData(sink);
+  auto done = std::make_shared<Notification>();
+  auto sink_impl = std::make_shared<DataSinkImplementation>();
+  {
+    MutexLock lock(&data_sources_mu_);
+    auto done_notifier = std::make_shared<DataSinkCompletionNotification>(
+        [done]() { done->Notify(); });
+    for (DataSource* data_source : data_sources_) {
+      data_source->AddData(DataSink(sink_impl, done_notifier));
+    }
   }
-  return sink.Finalize();
+  bool completed =
+      done->WaitForNotificationWithTimeout(absl::Milliseconds(100));
+  return sink_impl->Finalize(!completed);
 }
 
 void BaseNode::RunZTrace(
@@ -235,28 +177,88 @@ void BaseNode::RunZTrace(
   ztrace->Run(deadline, std::move(args), event_engine, std::move(callback));
 }
 
+void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
+                               upb_Arena* arena) {
+  grpc_channelz_v2_Entity_set_id(entity, uuid());
+  grpc_channelz_v2_Entity_set_kind(
+      entity, StdStringToUpbString(EntityTypeToKind(type_)));
+  {
+    MutexLock lock(&parent_mu_);
+    auto* parents =
+        grpc_channelz_v2_Entity_resize_parents(entity, parents_.size(), arena);
+    for (const auto& parent : parents_) {
+      *parents++ = parent->uuid();
+    }
+  }
+  grpc_channelz_v2_Entity_set_orphaned(entity, orphaned_index_ != 0);
+
+  auto done = std::make_shared<Notification>();
+  auto sink_impl = std::make_shared<DataSinkImplementation>();
+  auto done_notifier = std::make_shared<DataSinkCompletionNotification>(
+      [done]() { done->Notify(); });
+  auto make_data_sink = [sink_impl, done_notifier]() {
+    return DataSink(sink_impl, done_notifier);
+  };
+  AddNodeSpecificData(make_data_sink());
+  {
+    MutexLock lock(&data_sources_mu_);
+    for (DataSource* data_source : data_sources_) {
+      data_source->AddData(make_data_sink());
+    }
+  }
+  make_data_sink().AddData("v1_compatibility",
+                           PropertyList().Set("name", name()));
+  bool completed =
+      done->WaitForNotificationWithTimeout(absl::Milliseconds(100));
+  sink_impl->Finalize(!completed, entity, arena);
+
+  trace_.Render(entity, arena);
+}
+
+void BaseNode::AddNodeSpecificData(DataSink) {
+  // Default implementation does nothing.
+}
+
+std::string BaseNode::SerializeEntityToString() {
+  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);
+  size_t length;
+  auto* bytes = grpc_channelz_v2_Entity_serialize(entity, arena, &length);
+  return std::string(bytes, length);
+}
+
 //
 // DataSource
 //
 
-DataSource::DataSource(RefCountedPtr<BaseNode> node) : node_(std::move(node)) {
-  if (node_ == nullptr) return;
-  MutexLock lock(&node_->data_sources_mu_);
-  node_->data_sources_.push_back(this);
-}
+DataSource::DataSource(RefCountedPtr<BaseNode> node) : node_(std::move(node)) {}
 
 DataSource::~DataSource() {
   DCHECK(node_ == nullptr) << "DataSource must be ResetDataSource()'d in the "
                               "most derived class before destruction";
 }
 
-void DataSource::ResetDataSource() {
+void DataSource::SourceConstructed() {
+  if (node_ == nullptr) return;
+  MutexLock lock(&node_->data_sources_mu_);
+  node_->data_sources_.push_back(this);
+}
+
+void DataSource::SourceDestructing() {
   RefCountedPtr<BaseNode> node = std::move(node_);
   if (node == nullptr) return;
   MutexLock lock(&node->data_sources_mu_);
-  node->data_sources_.erase(
-      std::remove(node->data_sources_.begin(), node->data_sources_.end(), this),
-      node->data_sources_.end());
+  for (size_t i = 0; i < node->data_sources_.size(); ++i) {
+    if (node->data_sources_[i] == this) {
+      std::swap(node->data_sources_[i], node->data_sources_.back());
+      node->data_sources_.pop_back();
+      return;
+    }
+  }
+  LOG(DFATAL) << "DataSource not found in node's data sources -- probably "
+                 "SourceConstructed was not called";
 }
 
 //
@@ -295,6 +297,17 @@ void CallCounts::PopulateJson(Json::Object& json) const {
   }
 }
 
+PropertyList CallCounts::ToPropertyList() const {
+  return PropertyList()
+      .Set("calls_started", calls_started)
+      .Set("calls_succeeded", calls_succeeded)
+      .Set("calls_failed", calls_failed)
+      .Set("last_call_started_timestamp", [this]() -> std::optional<Timestamp> {
+        if (last_call_started_cycle == 0) return std::nullopt;
+        return Timestamp::FromCycleCounterRoundDown(last_call_started_cycle);
+      }());
+}
+
 //
 // PerCpuCallCountingHelper
 //
@@ -335,13 +348,14 @@ CallCounts PerCpuCallCountingHelper::GetCallCounts() const {
 // ChannelNode
 //
 
-ChannelNode::ChannelNode(std::string target, size_t channel_tracer_max_nodes,
+ChannelNode::ChannelNode(std::string target, size_t max_trace_memory,
                          bool is_internal_channel)
     : BaseNode(is_internal_channel ? EntityType::kInternalChannel
                                    : EntityType::kTopLevelChannel,
-               target),
-      target_(std::move(target)),
-      trace_(channel_tracer_max_nodes) {}
+               max_trace_memory, target),
+      target_(std::move(target)) {
+  NodeConstructed();
+}
 
 const char* ChannelNode::GetChannelConnectivityStateChangeString(
     grpc_connectivity_state state) {
@@ -405,7 +419,7 @@ Json ChannelNode::RenderJson() {
     });
   }
   // Fill in the channel trace if applicable.
-  Json trace_json = trace_.RenderJson();
+  Json trace_json = trace().RenderJson();
   if (trace_json.type() != Json::Type::kNull) {
     data["trace"] = std::move(trace_json);
   }
@@ -425,6 +439,14 @@ Json ChannelNode::RenderJson() {
   return Json::FromObject(std::move(json));
 }
 
+void ChannelNode::AddNodeSpecificData(DataSink sink) {
+  sink.AddData("channel", PropertyList()
+                              .Set("target", target_)
+                              .Set("connectivity_state", connectivity_state()));
+  sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
+}
+
 void ChannelNode::PopulateChildRefs(Json::Object* json) {
   auto child_subchannels = this->child_subchannels();
   auto child_channels = this->child_channels();
@@ -459,10 +481,11 @@ void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
 //
 
 SubchannelNode::SubchannelNode(std::string target_address,
-                               size_t channel_tracer_max_nodes)
-    : BaseNode(EntityType::kSubchannel, target_address),
-      target_(std::move(target_address)),
-      trace_(channel_tracer_max_nodes) {}
+                               size_t max_trace_memory)
+    : BaseNode(EntityType::kSubchannel, max_trace_memory, target_address),
+      target_(std::move(target_address)) {
+  NodeConstructed();
+}
 
 SubchannelNode::~SubchannelNode() {}
 
@@ -470,11 +493,6 @@ void SubchannelNode::UpdateConnectivityState(grpc_connectivity_state state) {
   connectivity_state_.store(state, std::memory_order_relaxed);
 }
 
-void SubchannelNode::SetChildSocket(RefCountedPtr<SocketNode> socket) {
-  MutexLock lock(&socket_mu_);
-  child_socket_ = std::move(socket);
-}
-
 std::string SubchannelNode::connectivity_state() const {
   grpc_connectivity_state state =
       connectivity_state_.load(std::memory_order_relaxed);
@@ -490,7 +508,7 @@ Json SubchannelNode::RenderJson() {
       {"target", Json::FromString(target_)},
   };
   // Fill in the channel trace if applicable
-  Json trace_json = trace_.RenderJson();
+  Json trace_json = trace().RenderJson();
   if (trace_json.type() != Json::Type::kNull) {
     data["trace"] = std::move(trace_json);
   }
@@ -504,16 +522,13 @@ Json SubchannelNode::RenderJson() {
       {"data", Json::FromObject(std::move(data))},
   };
   // Populate the child socket.
-  RefCountedPtr<SocketNode> child_socket;
-  {
-    MutexLock lock(&socket_mu_);
-    child_socket = child_socket_;
-  }
-  if (child_socket != nullptr && child_socket->uuid() != 0) {
+  auto [children, _] = ChannelzRegistry::GetChildrenOfType(
+      0, this, BaseNode::EntityType::kSocket, 1);
+  if (!children.empty()) {
     object["socketRef"] = Json::FromArray({
         Json::FromObject({
-            {"socketId", Json::FromString(absl::StrCat(child_socket->uuid()))},
-            {"name", Json::FromString(child_socket->name())},
+            {"socketId", Json::FromString(absl::StrCat(children[0]->uuid()))},
+            {"name", Json::FromString(children[0]->name())},
         }),
     });
   }
@@ -521,12 +536,22 @@ Json SubchannelNode::RenderJson() {
   return Json::FromObject(std::move(object));
 }
 
+void SubchannelNode::AddNodeSpecificData(DataSink sink) {
+  sink.AddData("channel", PropertyList()
+                              .Set("target", target_)
+                              .Set("connectivity_state", connectivity_state()));
+  sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
+}
+
 //
 // ServerNode
 //
 
-ServerNode::ServerNode(size_t channel_tracer_max_nodes)
-    : BaseNode(EntityType::kServer, ""), trace_(channel_tracer_max_nodes) {}
+ServerNode::ServerNode(size_t max_trace_memory)
+    : BaseNode(EntityType::kServer, max_trace_memory, "") {
+  NodeConstructed();
+}
 
 ServerNode::~ServerNode() {}
 
@@ -555,7 +580,7 @@ std::string ServerNode::RenderServerSockets(intptr_t start_socket_id,
 Json ServerNode::RenderJson() {
   Json::Object data;
   // Fill in the channel trace if applicable.
-  Json trace_json = trace_.RenderJson();
+  Json trace_json = trace().RenderJson();
   if (trace_json.type() != Json::Type::kNull) {
     data["trace"] = std::move(trace_json);
   }
@@ -586,26 +611,31 @@ Json ServerNode::RenderJson() {
   return Json::FromObject(std::move(object));
 }
 
-std::map<intptr_t, RefCountedPtr<ListenSocketNode>>
+void ServerNode::AddNodeSpecificData(DataSink sink) {
+  sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
+}
+
+std::map<intptr_t, WeakRefCountedPtr<ListenSocketNode>>
 ServerNode::child_listen_sockets() const {
-  std::map<intptr_t, RefCountedPtr<ListenSocketNode>> result;
+  std::map<intptr_t, WeakRefCountedPtr<ListenSocketNode>> result;
   auto [children, _] = ChannelzRegistry::GetChildrenOfType(
       0, this, BaseNode::EntityType::kListenSocket,
       std::numeric_limits<size_t>::max());
   for (const auto& child : children) {
-    result[child->uuid()] = child->RefAsSubclass<ListenSocketNode>();
+    result[child->uuid()] = child->WeakRefAsSubclass<ListenSocketNode>();
   }
   return result;
 }
 
-std::map<intptr_t, RefCountedPtr<SocketNode>> ServerNode::child_sockets()
+std::map<intptr_t, WeakRefCountedPtr<SocketNode>> ServerNode::child_sockets()
     const {
-  std::map<intptr_t, RefCountedPtr<SocketNode>> result;
+  std::map<intptr_t, WeakRefCountedPtr<SocketNode>> result;
   auto [children, _] = ChannelzRegistry::GetChildrenOfType(
       0, this, BaseNode::EntityType::kSocket,
       std::numeric_limits<size_t>::max());
   for (const auto& child : children) {
-    result[child->uuid()] = child->RefAsSubclass<SocketNode>();
+    result[child->uuid()] = child->WeakRefAsSubclass<SocketNode>();
   }
   return result;
 }
@@ -632,6 +662,27 @@ Json SocketNode::Security::Tls::RenderJson() {
   return Json::FromObject(std::move(data));
 }
 
+PropertyList SocketNode::Security::Tls::ToPropertyList() const {
+  PropertyList result;
+  switch (type) {
+    case NameType::kUnset:
+      break;
+    case NameType::kStandardName:
+      result.Set("standard_name", name);
+      break;
+    case NameType::kOtherName:
+      result.Set("other_name", name);
+      break;
+  }
+  if (!local_certificate.empty()) {
+    result.Set("local_certificate", absl::Base64Escape(local_certificate));
+  }
+  if (!remote_certificate.empty()) {
+    result.Set("remote_certificate", absl::Base64Escape(remote_certificate));
+  }
+  return result;
+}
+
 //
 // SocketNode::Security
 //
@@ -655,38 +706,22 @@ Json SocketNode::Security::RenderJson() {
   return Json::FromObject(std::move(data));
 }
 
-namespace {
-
-void* SecurityArgCopy(void* p) {
-  SocketNode::Security* xds_certificate_provider =
-      static_cast<SocketNode::Security*>(p);
-  return xds_certificate_provider->Ref().release();
-}
-
-void SecurityArgDestroy(void* p) {
-  SocketNode::Security* xds_certificate_provider =
-      static_cast<SocketNode::Security*>(p);
-  xds_certificate_provider->Unref();
-}
-
-int SecurityArgCmp(void* p, void* q) { return QsortCompare(p, q); }
-
-const grpc_arg_pointer_vtable kChannelArgVtable = {
-    SecurityArgCopy, SecurityArgDestroy, SecurityArgCmp};
-
-}  // namespace
-
-grpc_arg SocketNode::Security::MakeChannelArg() const {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_CHANNELZ_SECURITY),
-      const_cast<SocketNode::Security*>(this), &kChannelArgVtable);
-}
-
-RefCountedPtr<SocketNode::Security> SocketNode::Security::GetFromChannelArgs(
-    const grpc_channel_args* args) {
-  Security* security = grpc_channel_args_find_pointer<Security>(
-      args, GRPC_ARG_CHANNELZ_SECURITY);
-  return security != nullptr ? security->Ref() : nullptr;
+PropertyList SocketNode::Security::ToPropertyList() const {
+  switch (type) {
+    case ModelType::kUnset:
+      break;
+    case ModelType::kTls:
+      if (tls) {
+        return tls->ToPropertyList();
+      }
+      break;
+    case ModelType::kOther:
+      if (other.has_value()) {
+        return PropertyList().Set("other", JsonDump(*other));
+      }
+      break;
+  }
+  return PropertyList();
 }
 
 //
@@ -736,10 +771,12 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
 
 SocketNode::SocketNode(std::string local, std::string remote, std::string name,
                        RefCountedPtr<Security> security)
-    : BaseNode(EntityType::kSocket, std::move(name)),
+    : BaseNode(EntityType::kSocket, 0, std::move(name)),
       local_(std::move(local)),
       remote_(std::move(remote)),
-      security_(std::move(security)) {}
+      security_(std::move(security)) {
+  NodeConstructed();
+}
 
 void SocketNode::RecordStreamStartedFromLocal() {
   streams_started_.fetch_add(1, std::memory_order_relaxed);
@@ -845,13 +882,54 @@ Json SocketNode::RenderJson() {
   return Json::FromObject(std::move(object));
 }
 
+void SocketNode::AddNodeSpecificData(DataSink sink) {
+  auto convert_cycle_counter =
+      [](gpr_cycle_counter cycle_counter) -> std::optional<Timestamp> {
+    if (cycle_counter == 0) return std::nullopt;
+    return Timestamp::FromCycleCounterRoundDown(cycle_counter);
+  };
+  sink.AddData("socket",
+               PropertyList().Set("local", local_).Set("remote", remote_));
+  sink.AddData(
+      "call_counts",
+      PropertyList()
+          .Set("streams_started",
+               streams_started_.load(std::memory_order_relaxed))
+          .Set("streams_succeeded",
+               streams_succeeded_.load(std::memory_order_relaxed))
+          .Set("streams_failed",
+               streams_failed_.load(std::memory_order_relaxed))
+          .Set("messages_sent", messages_sent_.load(std::memory_order_relaxed))
+          .Set("messages_received",
+               messages_received_.load(std::memory_order_relaxed))
+          .Set("keepalives_sent",
+               keepalives_sent_.load(std::memory_order_relaxed))
+          .Set("last_local_stream_created_timestamp",
+               convert_cycle_counter(last_local_stream_created_cycle_.load(
+                   std::memory_order_relaxed)))
+          .Set("last_remote_stream_created_timestamp",
+               convert_cycle_counter(last_remote_stream_created_cycle_.load(
+                   std::memory_order_relaxed)))
+          .Set("last_message_sent_timestamp",
+               convert_cycle_counter(
+                   last_message_sent_cycle_.load(std::memory_order_relaxed)))
+          .Set("last_message_received_timestamp",
+               convert_cycle_counter(last_message_received_cycle_.load(
+                   std::memory_order_relaxed))));
+  if (security_ != nullptr) {
+    sink.AddData("security", security_->ToPropertyList());
+  }
+}
+
 //
 // ListenSocketNode
 //
 
 ListenSocketNode::ListenSocketNode(std::string local_addr, std::string name)
-    : BaseNode(EntityType::kListenSocket, std::move(name)),
-      local_addr_(std::move(local_addr)) {}
+    : BaseNode(EntityType::kListenSocket, 0, std::move(name)),
+      local_addr_(std::move(local_addr)) {
+  NodeConstructed();
+}
 
 Json ListenSocketNode::RenderJson() {
   Json::Object object = {
@@ -865,6 +943,10 @@ Json ListenSocketNode::RenderJson() {
   return Json::FromObject(std::move(object));
 }
 
+void ListenSocketNode::AddNodeSpecificData(DataSink sink) {
+  sink.AddData("listen_socket", PropertyList().Set("local", local_addr_));
+}
+
 //
 // CallNode
 //