grpc 1.73.0 → 1.75.0

data/src/core/channelz/channelz.h

@@ -32,6 +32,7 @@
 #include <optional>
 #include <set>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -50,6 +51,7 @@
 #include "src/core/util/time.h"
 #include "src/core/util/time_precise.h"
 #include "src/core/util/useful.h"
+#include "src/proto/grpc/channelz/v2/channelz.upb.h"
 
 // Channel arg key for channelz node.
 #define GRPC_ARG_CHANNELZ_CHANNEL_NODE \
@@ -80,6 +82,8 @@ namespace channelz {
 class SocketNode;
 class ListenSocketNode;
 class DataSource;
+class DataSink;
+class PropertyList;
 class ZTrace;
 
 namespace testing {
@@ -101,6 +105,7 @@ class BaseNode : public DualRefCounted<BaseNode> {
     kListenSocket,
     kSocket,
     kCall,
+    kResourceQuota,
   };
 
   static absl::string_view EntityTypeString(EntityType type) {
@@ -119,12 +124,51 @@ class BaseNode : public DualRefCounted<BaseNode> {
         return "socket";
       case EntityType::kCall:
         return "call";
+      case EntityType::kResourceQuota:
+        return "resource_quota";
     }
     return "unknown";
   }
 
+  static absl::string_view EntityTypeToKind(EntityType type) {
+    switch (type) {
+      case EntityType::kTopLevelChannel:
+        return "channel";
+      case EntityType::kInternalChannel:
+        return "internal_channel";
+      case EntityType::kSubchannel:
+        return "subchannel";
+      case EntityType::kServer:
+        return "server";
+      case EntityType::kListenSocket:
+        return "listen_socket";
+      case EntityType::kSocket:
+        return "socket";
+      case EntityType::kCall:
+        return "call";
+      case EntityType::kResourceQuota:
+        return "resource_quota";
+    }
+  }
+
+  static std::optional<EntityType> KindToEntityType(absl::string_view kind) {
+    if (kind == "channel") return EntityType::kTopLevelChannel;
+    if (kind == "internal_channel") return EntityType::kInternalChannel;
+    if (kind == "subchannel") return EntityType::kSubchannel;
+    if (kind == "server") return EntityType::kServer;
+    if (kind == "listen_socket") return EntityType::kListenSocket;
+    if (kind == "socket") return EntityType::kSocket;
+    if (kind == "call") return EntityType::kCall;
+    if (kind == "resource_quota") return EntityType::kResourceQuota;
+    return std::nullopt;
+  }
+
  protected:
-  BaseNode(EntityType type, std::string name);
+  BaseNode(EntityType type, size_t max_trace_memory, std::string name);
+
+  // Leaf derived types should call NodeConstructed() in their constructors
+  // to complete the initialization.
+  void NodeConstructed();
 
  public:
   void Orphaned() override;
@@ -173,8 +217,25 @@ class BaseNode : public DualRefCounted<BaseNode> {
                  absl::AnyInvocable<void(Json output)> callback);
   Json::Object AdditionalInfo();
 
+  const ChannelTrace& trace() const { return trace_; }
+  template <typename... Args>
+  ChannelTrace::Node NewTraceNode(Args&&... args) {
+    return trace_.NewNode(std::forward<Args>(args)...);
+  }
+  ChannelTrace& mutable_trace() { return trace_; }
+
+  void SerializeEntity(grpc_channelz_v2_Entity* entity, upb_Arena* arena);
+
+  std::string SerializeEntityToString();
+
  protected:
   void PopulateJsonFromDataSources(Json::Object& json);
+  // V2: Add any node-specific data to the sink.
+  // This is information that used to be provided by overloaded RenderJson
+  // methods.
+  // Over time the hope is that we can eliminate this method and move all
+  // functionality into data sources.
+  virtual void AddNodeSpecificData(DataSink sink);
 
  private:
   // to allow the ChannelzRegistry to set uuid_ under its lock.
@@ -188,6 +249,7 @@ class BaseNode : public DualRefCounted<BaseNode> {
   intptr_t UuidSlow();
 
   const EntityType type_;
+  bool node_constructed_called_ = false;
   uint64_t orphaned_index_ = 0;  // updated by registry
   std::atomic<intptr_t> uuid_;
   std::string name_;
@@ -198,8 +260,22 @@ class BaseNode : public DualRefCounted<BaseNode> {
   BaseNode* next_;  // updated by registry
   mutable Mutex parent_mu_;
   ParentSet parents_ ABSL_GUARDED_BY(parent_mu_);
+  ChannelTrace trace_;
 };
 
+namespace detail {
+inline ChannelTrace* LogOutputFrom(BaseNode* n) {
+  if (n == nullptr) return nullptr;
+  return LogOutputFrom(n->mutable_trace());
+}
+
+template <typename N>
+inline std::enable_if_t<std::is_base_of_v<BaseNode, N>, ChannelTrace*>
+LogOutputFrom(const RefCountedPtr<N>& n) {
+  return LogOutputFrom(n.get());
+}
+}  // namespace detail
+
 class ZTrace {
  public:
   virtual ~ZTrace() = default;
@@ -209,15 +285,79 @@ class ZTrace {
                    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.
+// We form a shared_ptr<> around this class during collection.
+// In DataSink we use a weak_ptr<> to allow rapid resource reclamation once
+// the collection is complete (or has timed out).
+class DataSinkImplementation {
+ public:
+  class Data {
+   public:
+    virtual ~Data() = default;
+    virtual Json::Object ToJson() = 0;
+    virtual void FillProto(google_protobuf_Any* any, upb_Arena* arena) = 0;
+  };
+
+  void AddData(absl::string_view name, std::unique_ptr<Data> data);
+  Json::Object Finalize(bool timed_out);
+  void Finalize(bool timed_out, grpc_channelz_v2_Entity* entity,
+                upb_Arena* arena);
+
+ private:
+  Mutex mu_;
+  std::map<std::string, std::unique_ptr<Data>> additional_info_
+      ABSL_GUARDED_BY(mu_);
+};
+
+// Wrapper around absl::AnyInvocable<void()> that is used to notify when the
+// DataSink has completed.
+// We hold a shared_ptr<> around this class in DataSink to keep knowledge of
+// when the DataSink has completed.
+class DataSinkCompletionNotification {
+ public:
+  explicit DataSinkCompletionNotification(absl::AnyInvocable<void()> callback)
+      : callback_(std::move(callback)) {}
+  ~DataSinkCompletionNotification() { callback_(); }
+
+ private:
+  absl::AnyInvocable<void()> callback_;
+};
+
 class DataSink {
  public:
-  virtual void AddAdditionalInfo(absl::string_view name,
-                                 Json::Object additional_info) = 0;
-  virtual void AddChildObjects(
-      std::vector<RefCountedPtr<BaseNode>> children) = 0;
+  DataSink(std::shared_ptr<DataSinkImplementation> impl,
+           std::shared_ptr<DataSinkCompletionNotification> notification)
+      : impl_(impl), notification_(std::move(notification)) {}
+
+  template <typename T>
+  std::void_t<decltype(std::declval<T>().TakeJsonObject())> AddData(
+      absl::string_view name, T value) {
+    class DataImpl final : public DataSinkImplementation::Data {
+     public:
+      explicit DataImpl(T value) : value_(std::move(value)) {}
+      Json::Object ToJson() override { return value_.TakeJsonObject(); }
+      void FillProto(google_protobuf_Any* any, upb_Arena* arena) override {
+        value_.FillAny(any, arena);
+      }
+
+     private:
+      T value_;
+    };
+    AddData(name, std::make_unique<DataImpl>(std::move(value)));
+  }
 
- protected:
-  ~DataSink() = default;
+ private:
+  void AddData(absl::string_view name,
+               std::unique_ptr<DataSinkImplementation::Data> data) {
+    auto impl = impl_.lock();
+    if (impl == nullptr) return;
+    impl->AddData(name, std::move(data));
+  }
+
+  std::weak_ptr<DataSinkImplementation> impl_;
+  std::shared_ptr<DataSinkCompletionNotification> notification_;
 };
 
 class DataSource {
@@ -227,7 +367,7 @@ class DataSource {
   // Add any relevant json fragments to the output.
   // This method must not cause the DataSource to be deleted, or else there will
   // be a deadlock.
-  virtual void AddData(DataSink&) {}
+  virtual void AddData(DataSink) {}
 
   // If this data source exports some ztrace, return it here.
   virtual std::unique_ptr<ZTrace> GetZTrace(absl::string_view /*name*/) {
@@ -237,12 +377,17 @@ class DataSource {
  protected:
   ~DataSource();
   RefCountedPtr<BaseNode> channelz_node() { return node_; }
+  const BaseNode* channelz_node() const { return node_.get(); }
+
+  // This method must be called in the most derived class's constructor.
+  // It adds this data source to the node's list of data sources.
+  void SourceConstructed();
 
   // This method must be called in the most derived class's destructor.
   // It removes this data source from the node's list of data sources.
   // If it is not called, then the AddData() function pointer may be invalid
   // when the node is queried.
-  void ResetDataSource();
+  void SourceDestructing();
 
  private:
   RefCountedPtr<BaseNode> node_;
@@ -260,6 +405,7 @@ struct CallCounts {
   }
 
   void PopulateJson(Json::Object& json) const;
+  PropertyList ToPropertyList() const;
 };
 
 // This class is a helper class for channelz entities that deal with Channels,
@@ -319,11 +465,15 @@ class PerCpuCallCountingHelper final {
 // Handles channelz bookkeeping for channels
 class ChannelNode final : public BaseNode {
  public:
-  ChannelNode(std::string target, size_t channel_tracer_max_nodes,
+  ChannelNode(std::string target, size_t max_trace_memory,
               bool is_internal_channel);
 
   void Orphaned() override {
-    channel_args_ = ChannelArgs();
+    ChannelArgs to_destroy;
+    {
+      MutexLock lock(&channel_args_mu_);
+      std::swap(channel_args_, to_destroy);
+    }
     BaseNode::Orphaned();
   }
 
@@ -341,16 +491,10 @@ class ChannelNode final : public BaseNode {
   Json RenderJson() override;
 
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
-    trace_.AddTraceEvent(severity, data);
-  }
-  void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  const grpc_slice& data,
-                                  RefCountedPtr<BaseNode> referenced_channel) {
-    trace_.AddTraceEventWithReference(severity, data,
-                                      std::move(referenced_channel));
-  }
   void SetChannelArgs(const ChannelArgs& channel_args) {
+    ChannelArgs to_destroy;
+    MutexLock lock(&channel_args_mu_);
+    std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
   void RecordCallStarted() { call_counter_.RecordCallStarted(); }
@@ -364,18 +508,21 @@ class ChannelNode final : public BaseNode {
   CallCounts GetCallCounts() const { return call_counter_.GetCallCounts(); }
   std::set<intptr_t> child_channels() const;
   std::set<intptr_t> child_subchannels() const;
-  const ChannelTrace& trace() const { return trace_; }
-  const ChannelArgs& channel_args() const { return channel_args_; }
+  ChannelArgs channel_args() const {
+    MutexLock lock(&channel_args_mu_);
+    return channel_args_;
+  }
 
  private:
   void PopulateChildRefs(Json::Object* json);
+  void AddNodeSpecificData(DataSink sink) override;
 
   std::string target_;
   CallCountingHelper call_counter_;
-  ChannelTrace trace_;
   // TODO(ctiller): keeping channel args here can create odd circular references
   // that are hard to reason about. Consider moving this to a DataSource.
-  ChannelArgs channel_args_;
+  mutable Mutex channel_args_mu_;
+  ChannelArgs channel_args_ ABSL_GUARDED_BY(channel_args_mu_);
 
   // Least significant bit indicates whether the value is set.  Remaining
   // bits are a grpc_connectivity_state value.
@@ -385,37 +532,30 @@ class ChannelNode final : public BaseNode {
 // Handles channelz bookkeeping for subchannels
 class SubchannelNode final : public BaseNode {
  public:
-  SubchannelNode(std::string target_address, size_t channel_tracer_max_nodes);
+  SubchannelNode(std::string target_address, size_t max_trace_memory);
   ~SubchannelNode() override;
 
   void Orphaned() override {
-    channel_args_ = ChannelArgs();
+    ChannelArgs to_destroy;
+    {
+      MutexLock lock(&channel_args_mu_);
+      std::swap(channel_args_, to_destroy);
+    }
     BaseNode::Orphaned();
   }
 
   // Sets the subchannel's connectivity state without health checking.
   void UpdateConnectivityState(grpc_connectivity_state state);
 
-  // Used when the subchannel's child socket changes. This should be set when
-  // the subchannel's transport is created and set to nullptr when the
-  // subchannel unrefs the transport.
-  void SetChildSocket(RefCountedPtr<SocketNode> socket);
-
   Json RenderJson() override;
 
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
-    trace_.AddTraceEvent(severity, data);
-  }
   void SetChannelArgs(const ChannelArgs& channel_args) {
+    ChannelArgs to_destroy;
+    MutexLock lock(&channel_args_mu_);
+    std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
-  void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  const grpc_slice& data,
-                                  RefCountedPtr<BaseNode> referenced_channel) {
-    trace_.AddTraceEventWithReference(severity, data,
-                                      std::move(referenced_channel));
-  }
   void RecordCallStarted() { call_counter_.RecordCallStarted(); }
   void RecordCallFailed() { call_counter_.RecordCallFailed(); }
   void RecordCallSucceeded() { call_counter_.RecordCallSucceeded(); }
@@ -423,37 +563,39 @@ class SubchannelNode final : public BaseNode {
   const std::string& target() const { return target_; }
   std::string connectivity_state() const;
   CallCounts GetCallCounts() const { return call_counter_.GetCallCounts(); }
-  RefCountedPtr<SocketNode> child_socket() const {
-    MutexLock lock(&socket_mu_);
-    return child_socket_;
+  ChannelArgs channel_args() const {
+    MutexLock lock(&channel_args_mu_);
+    return channel_args_;
   }
-  const ChannelTrace& trace() const { return trace_; }
-  const ChannelArgs& channel_args() const { return channel_args_; }
 
  private:
+  void AddNodeSpecificData(DataSink sink) override;
+
   // Allows the channel trace test to access trace_.
   friend class testing::SubchannelNodePeer;
 
   std::atomic<grpc_connectivity_state> connectivity_state_{GRPC_CHANNEL_IDLE};
-  mutable Mutex socket_mu_;
-  RefCountedPtr<SocketNode> child_socket_ ABSL_GUARDED_BY(socket_mu_);
   std::string target_;
   CallCountingHelper call_counter_;
-  ChannelTrace trace_;
   // TODO(ctiller): keeping channel args here can create odd circular references
   // that are hard to reason about. Consider moving this to a DataSource.
-  ChannelArgs channel_args_;
+  mutable Mutex channel_args_mu_;
+  ChannelArgs channel_args_ ABSL_GUARDED_BY(channel_args_mu_);
 };
 
 // Handles channelz bookkeeping for servers
 class ServerNode final : public BaseNode {
  public:
-  explicit ServerNode(size_t channel_tracer_max_nodes);
+  explicit ServerNode(size_t max_trace_memory);
 
   ~ServerNode() override;
 
   void Orphaned() override {
-    channel_args_ = ChannelArgs();
+    ChannelArgs to_destroy;
+    {
+      MutexLock lock(&channel_args_mu_);
+      std::swap(channel_args_, to_destroy);
+    }
     BaseNode::Orphaned();
   }
 
@@ -463,16 +605,10 @@ class ServerNode final : public BaseNode {
                                   intptr_t max_results);
 
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
-    trace_.AddTraceEvent(severity, data);
-  }
-  void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  const grpc_slice& data,
-                                  RefCountedPtr<BaseNode> referenced_channel) {
-    trace_.AddTraceEventWithReference(severity, data,
-                                      std::move(referenced_channel));
-  }
   void SetChannelArgs(const ChannelArgs& channel_args) {
+    ChannelArgs to_destroy;
+    MutexLock lock(&channel_args_mu_);
+    std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
   void RecordCallStarted() { call_counter_.RecordCallStarted(); }
@@ -481,19 +617,23 @@ class ServerNode final : public BaseNode {
 
   CallCounts GetCallCounts() const { return call_counter_.GetCallCounts(); }
 
-  std::map<intptr_t, RefCountedPtr<ListenSocketNode>> child_listen_sockets()
+  std::map<intptr_t, WeakRefCountedPtr<ListenSocketNode>> child_listen_sockets()
       const;
-  std::map<intptr_t, RefCountedPtr<SocketNode>> child_sockets() const;
+  std::map<intptr_t, WeakRefCountedPtr<SocketNode>> child_sockets() const;
 
-  const ChannelTrace& trace() const { return trace_; }
-  const ChannelArgs& channel_args() const { return channel_args_; }
+  ChannelArgs channel_args() const {
+    MutexLock lock(&channel_args_mu_);
+    return channel_args_;
+  }
 
  private:
+  void AddNodeSpecificData(DataSink sink) override;
+
   PerCpuCallCountingHelper call_counter_;
-  ChannelTrace trace_;
   // TODO(ctiller): keeping channel args here can create odd circular references
   // that are hard to reason about. Consider moving this to a DataSource.
-  ChannelArgs channel_args_;
+  mutable Mutex channel_args_mu_;
+  ChannelArgs channel_args_ ABSL_GUARDED_BY(channel_args_mu_);
 };
 
 #define GRPC_ARG_CHANNELZ_SECURITY "grpc.internal.channelz_security"
@@ -514,6 +654,7 @@ class SocketNode final : public BaseNode {
       std::string remote_certificate;
 
       Json RenderJson();
+      PropertyList ToPropertyList() const;
     };
     enum class ModelType { kUnset = 0, kTls = 1, kOther = 2 };
     ModelType type = ModelType::kUnset;
@@ -521,6 +662,7 @@ class SocketNode final : public BaseNode {
     std::optional<Json> other;
 
     Json RenderJson();
+    PropertyList ToPropertyList() const;
 
     static absl::string_view ChannelArgName() {
       return GRPC_ARG_CHANNELZ_SECURITY;
@@ -529,11 +671,6 @@ class SocketNode final : public BaseNode {
     static int ChannelArgsCompare(const Security* a, const Security* b) {
       return QsortCompare(a, b);
     }
-
-    grpc_arg MakeChannelArg() const;
-
-    static RefCountedPtr<Security> GetFromChannelArgs(
-        const grpc_channel_args* args);
   };
 
   SocketNode(std::string local, std::string remote, std::string name,
@@ -602,6 +739,7 @@ class SocketNode final : public BaseNode {
       gpr_cycle_counter cycle_counter) const {
     return gpr_format_timespec(gpr_cycle_counter_to_time(cycle_counter));
   }
+  void AddNodeSpecificData(DataSink sink) override;
 
   std::atomic<int64_t> streams_started_{0};
   std::atomic<int64_t> streams_succeeded_{0};
@@ -627,17 +765,31 @@ class ListenSocketNode final : public BaseNode {
   Json RenderJson() override;
 
  private:
+  void AddNodeSpecificData(DataSink sink) override;
+
   std::string local_addr_;
 };
 
 class CallNode final : public BaseNode {
  public:
   explicit CallNode(std::string name)
-      : BaseNode(EntityType::kCall, std::move(name)) {}
+      : BaseNode(EntityType::kCall, 0, std::move(name)) {
+    NodeConstructed();
+  }
 
   Json RenderJson() override;
 };
 
+class ResourceQuotaNode final : public BaseNode {
+ public:
+  explicit ResourceQuotaNode(std::string name)
+      : BaseNode(EntityType::kResourceQuota, 0, std::move(name)) {
+    NodeConstructed();
+  }
+
+  Json RenderJson() override { return Json::FromString("ResourceQuota"); }
+};
+
 }  // namespace channelz
 }  // namespace grpc_core