grpc 1.74.1 → 1.75.0.pre1

data/src/core/call/metadata.cc

@@ -34,6 +34,28 @@ ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
   return hdl;
 }
 
+absl::Status ServerMetadataToStatus(ServerMetadata& md) {
+  const auto grpc_status =
+      md.get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
+  const auto* error_slice = md.get_pointer(GrpcMessageMetadata());
+  return grpc_error_set_int(
+      absl::Status(static_cast<absl::StatusCode>(grpc_status),
+                   error_slice->as_string_view()),
+      StatusIntProperty::kRpcStatus, grpc_status);
+}
+
+void SetServerMetadataFromStatus(ServerMetadata& md,
+                                 const absl::Status& status) {
+  grpc_status_code code;
+  std::string message;
+  grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,
+                        nullptr, nullptr);
+  md.Set(GrpcStatusMetadata(), code);
+  if (!status.ok()) {
+    md.Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  }
+}
+
 ServerMetadataHandle CancelledServerMetadataFromStatus(
     const absl::Status& status) {
   auto hdl = ServerMetadataFromStatus(status);

data/src/core/call/metadata.h

@@ -32,6 +32,14 @@ using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
 using ClientMetadata = grpc_metadata_batch;
 using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
 
+// Convert absl::Status to ServerMetadata
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status);
+
+absl::Status ServerMetadataToStatus(ServerMetadata& md);
+
+void SetServerMetadataFromStatus(ServerMetadata& md,
+                                 const absl::Status& status);
+
 template <typename T>
 class ServerMetadataOrHandle {
  public:
@@ -95,6 +103,22 @@ struct FailureStatusCastImpl<ServerMetadataOrHandle<T>, ServerMetadataHandle&> {
   }
 };
 
+template <>
+struct FailureStatusCastImpl<ServerMetadataOrHandle<ServerMetadata>,
+                             const absl::Status&> {
+  static ServerMetadataOrHandle<ServerMetadata> Cast(const absl::Status& t) {
+    return ServerMetadataOrHandle<ServerMetadata>::Failure(
+        ServerMetadataFromStatus(t));
+  }
+};
+
+template <>
+struct FailureStatusCastImpl<absl::Status, ServerMetadataHandle&> {
+  static absl::Status Cast(ServerMetadataHandle& t) {
+    return ServerMetadataToStatus(*t);
+  }
+};
+
 template <>
 struct FailureStatusCastImpl<ServerMetadataHandle, ServerMetadataHandle&> {
   static ServerMetadataHandle Cast(ServerMetadataHandle& t) {
@@ -156,8 +180,6 @@ inline bool IsStatusOk(const ServerMetadataHandle& m) {
          GRPC_STATUS_OK;
 }
 
-// Convert absl::Status to ServerMetadata
-ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status);
 // Convert absl::Status to ServerMetadata, and set GrpcCallWasCancelled() to
 // true
 ServerMetadataHandle CancelledServerMetadataFromStatus(

data/src/core/channelz/channelz.cc

@@ -206,6 +206,8 @@ void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
       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);
@@ -442,7 +444,7 @@ void ChannelNode::AddNodeSpecificData(DataSink sink) {
                               .Set("target", target_)
                               .Set("connectivity_state", connectivity_state()));
   sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
-  sink.AddData("channel_args", channel_args_.ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
 }
 
 void ChannelNode::PopulateChildRefs(Json::Object* json) {
@@ -491,12 +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_ =
-      socket == nullptr ? nullptr : socket->WeakRefAsSubclass<SocketNode>();
-}
-
 std::string SubchannelNode::connectivity_state() const {
   grpc_connectivity_state state =
       connectivity_state_.load(std::memory_order_relaxed);
@@ -526,16 +522,13 @@ Json SubchannelNode::RenderJson() {
       {"data", Json::FromObject(std::move(data))},
   };
   // Populate the child socket.
-  WeakRefCountedPtr<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())},
         }),
     });
   }
@@ -548,7 +541,7 @@ void SubchannelNode::AddNodeSpecificData(DataSink sink) {
                               .Set("target", target_)
                               .Set("connectivity_state", connectivity_state()));
   sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
-  sink.AddData("channel_args", channel_args_.ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
 }
 
 //
@@ -620,7 +613,7 @@ Json ServerNode::RenderJson() {
 
 void ServerNode::AddNodeSpecificData(DataSink sink) {
   sink.AddData("call_counts", call_counter_.GetCallCounts().ToPropertyList());
-  sink.AddData("channel_args", channel_args_.ToPropertyList());
+  sink.AddData("channel_args", channel_args().ToPropertyList());
 }
 
 std::map<intptr_t, WeakRefCountedPtr<ListenSocketNode>>

data/src/core/channelz/channelz.h

@@ -105,6 +105,7 @@ class BaseNode : public DualRefCounted<BaseNode> {
     kListenSocket,
     kSocket,
     kCall,
+    kResourceQuota,
   };
 
   static absl::string_view EntityTypeString(EntityType type) {
@@ -123,6 +124,8 @@ class BaseNode : public DualRefCounted<BaseNode> {
         return "socket";
       case EntityType::kCall:
         return "call";
+      case EntityType::kResourceQuota:
+        return "resource_quota";
     }
     return "unknown";
   }
@@ -143,6 +146,8 @@ class BaseNode : public DualRefCounted<BaseNode> {
         return "socket";
       case EntityType::kCall:
         return "call";
+      case EntityType::kResourceQuota:
+        return "resource_quota";
     }
   }
 
@@ -154,6 +159,7 @@ class BaseNode : public DualRefCounted<BaseNode> {
     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;
   }
 
@@ -371,6 +377,7 @@ 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.
@@ -462,7 +469,11 @@ class ChannelNode final : public BaseNode {
               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();
   }
 
@@ -481,6 +492,9 @@ class ChannelNode final : public BaseNode {
 
   // proxy methods to composed classes.
   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(); }
@@ -494,7 +508,10 @@ 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 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);
@@ -504,7 +521,8 @@ class ChannelNode final : public BaseNode {
   CallCountingHelper call_counter_;
   // 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.
@@ -518,22 +536,24 @@ class SubchannelNode final : public BaseNode {
   ~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 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(); }
@@ -543,11 +563,10 @@ class SubchannelNode final : public BaseNode {
   const std::string& target() const { return target_; }
   std::string connectivity_state() const;
   CallCounts GetCallCounts() const { return call_counter_.GetCallCounts(); }
-  WeakRefCountedPtr<SocketNode> child_socket() const {
-    MutexLock lock(&socket_mu_);
-    return child_socket_;
+  ChannelArgs channel_args() const {
+    MutexLock lock(&channel_args_mu_);
+    return channel_args_;
   }
-  const ChannelArgs& channel_args() const { return channel_args_; }
 
  private:
   void AddNodeSpecificData(DataSink sink) override;
@@ -556,13 +575,12 @@ class SubchannelNode final : public BaseNode {
   friend class testing::SubchannelNodePeer;
 
   std::atomic<grpc_connectivity_state> connectivity_state_{GRPC_CHANNEL_IDLE};
-  mutable Mutex socket_mu_;
-  WeakRefCountedPtr<SocketNode> child_socket_ ABSL_GUARDED_BY(socket_mu_);
   std::string target_;
   CallCountingHelper call_counter_;
   // 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
@@ -573,7 +591,11 @@ class ServerNode final : public BaseNode {
   ~ServerNode() override;
 
   void Orphaned() override {
-    channel_args_ = ChannelArgs();
+    ChannelArgs to_destroy;
+    {
+      MutexLock lock(&channel_args_mu_);
+      std::swap(channel_args_, to_destroy);
+    }
     BaseNode::Orphaned();
   }
 
@@ -584,6 +606,9 @@ class ServerNode final : public BaseNode {
 
   // proxy methods to composed classes.
   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(); }
@@ -596,7 +621,10 @@ class ServerNode final : public BaseNode {
       const;
   std::map<intptr_t, WeakRefCountedPtr<SocketNode>> child_sockets() const;
 
-  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;
@@ -604,7 +632,8 @@ class ServerNode final : public BaseNode {
   PerCpuCallCountingHelper call_counter_;
   // 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"
@@ -751,6 +780,16 @@ class CallNode final : public BaseNode {
   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
 

data/src/core/channelz/channelz_registry.cc

@@ -47,61 +47,6 @@
 namespace grpc_core {
 namespace channelz {
 
-namespace {
-template <typename T>
-std::string RenderArray(std::tuple<T, bool> values_and_end,
-                        const std::string& key) {
-  auto& [values, end] = values_and_end;
-  Json::Object object;
-  if (!values.empty()) {
-    // Create list of channels.
-    Json::Array array;
-    for (size_t i = 0; i < values.size(); ++i) {
-      array.emplace_back(values[i]->RenderJson());
-    }
-    object[key] = Json::FromArray(std::move(array));
-  }
-  if (end) {
-    object["end"] = Json::FromBool(true);
-  }
-  return JsonDump(Json::FromObject(std::move(object)));
-}
-
-Json RemoveAdditionalInfo(const Json& json) {
-  switch (json.type()) {
-    case Json::Type::kArray: {
-      Json::Array out;
-      for (const auto& node : json.array()) {
-        out.emplace_back(RemoveAdditionalInfo(node));
-      }
-      return Json::FromArray(std::move(out));
-    } break;
-    case Json::Type::kObject: {
-      Json::Object out;
-      for (const auto& [key, value] : json.object()) {
-        if (key == "additionalInfo") continue;
-        out[key] = RemoveAdditionalInfo(value);
-      }
-      return Json::FromObject(std::move(out));
-    } break;
-    default:
-      return json;
-  }
-}
-
-// TODO(ctiller): Temporary hack to remove fields that are objectionable to the
-// protobuf parser (because we've not published them in protobuf yet).
-char* ApplyHacks(const std::string& json_str) {
-  return gpr_strdup(StripAdditionalInfoFromJson(json_str).c_str());
-}
-}  // namespace
-
-std::string StripAdditionalInfoFromJson(absl::string_view json_str) {
-  auto json = JsonParse(json_str);
-  if (!json.ok()) return gpr_strdup(std::string(json_str).c_str());
-  return JsonDump(RemoveAdditionalInfo(*json));
-}
-
 ChannelzRegistry* ChannelzRegistry::Default() {
   static ChannelzRegistry* singleton = new ChannelzRegistry();
   return singleton;
@@ -121,14 +66,6 @@ void ChannelzRegistry::InternalLogAllEntities() {
   }
 }
 
-std::string ChannelzRegistry::GetTopChannelsJson(intptr_t start_channel_id) {
-  return RenderArray(GetTopChannels(start_channel_id), "channel");
-}
-
-std::string ChannelzRegistry::GetServersJson(intptr_t start_server_id) {
-  return RenderArray(GetServers(start_server_id), "server");
-}
-
 void ChannelzRegistry::InternalRegister(BaseNode* node) {
   DCHECK_EQ(node->uuid_, -1);
   const size_t node_shard_index = NodeShardIndex(node);
@@ -379,102 +316,3 @@ void ChannelzRegistry::TestOnlyReset() {
 
 }  // namespace channelz
 }  // namespace grpc_core
-
-char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
-  grpc_core::ExecCtx exec_ctx;
-  return grpc_core::channelz::ApplyHacks(
-      grpc_core::channelz::ChannelzRegistry::GetTopChannelsJson(
-          start_channel_id)
-          .c_str());
-}
-
-char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  grpc_core::ExecCtx exec_ctx;
-  return grpc_core::channelz::ApplyHacks(
-      grpc_core::channelz::ChannelzRegistry::GetServersJson(start_server_id)
-          .c_str());
-}
-
-char* grpc_channelz_get_server(intptr_t server_id) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> server_node =
-      grpc_core::channelz::ChannelzRegistry::Get(server_id);
-  if (server_node == nullptr ||
-      server_node->type() !=
-          grpc_core::channelz::BaseNode::EntityType::kServer) {
-    return nullptr;
-  }
-  grpc_core::Json json = grpc_core::Json::FromObject({
-      {"server", server_node->RenderJson()},
-  });
-  return grpc_core::channelz::ApplyHacks(grpc_core::JsonDump(json).c_str());
-}
-
-char* grpc_channelz_get_server_sockets(intptr_t server_id,
-                                       intptr_t start_socket_id,
-                                       intptr_t max_results) {
-  grpc_core::ExecCtx exec_ctx;
-  // Validate inputs before handing them of to the renderer.
-  grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> base_node =
-      grpc_core::channelz::ChannelzRegistry::Get(server_id);
-  if (base_node == nullptr ||
-      base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer ||
-      start_socket_id < 0 || max_results < 0) {
-    return nullptr;
-  }
-  // This cast is ok since we have just checked to make sure base_node is
-  // actually a server node.
-  grpc_core::channelz::ServerNode* server_node =
-      static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
-  return grpc_core::channelz::ApplyHacks(
-      server_node->RenderServerSockets(start_socket_id, max_results).c_str());
-}
-
-char* grpc_channelz_get_channel(intptr_t channel_id) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
-      grpc_core::channelz::ChannelzRegistry::Get(channel_id);
-  if (channel_node == nullptr ||
-      (channel_node->type() !=
-           grpc_core::channelz::BaseNode::EntityType::kTopLevelChannel &&
-       channel_node->type() !=
-           grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
-    return nullptr;
-  }
-  grpc_core::Json json = grpc_core::Json::FromObject({
-      {"channel", channel_node->RenderJson()},
-  });
-  return grpc_core::channelz::ApplyHacks(grpc_core::JsonDump(json).c_str());
-}
-
-char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> subchannel_node =
-      grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
-  if (subchannel_node == nullptr ||
-      subchannel_node->type() !=
-          grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
-    return nullptr;
-  }
-  grpc_core::Json json = grpc_core::Json::FromObject({
-      {"subchannel", subchannel_node->RenderJson()},
-  });
-  return grpc_core::channelz::ApplyHacks(grpc_core::JsonDump(json).c_str());
-}
-
-char* grpc_channelz_get_socket(intptr_t socket_id) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
-      grpc_core::channelz::ChannelzRegistry::Get(socket_id);
-  if (socket_node == nullptr ||
-      (socket_node->type() !=
-           grpc_core::channelz::BaseNode::EntityType::kSocket &&
-       socket_node->type() !=
-           grpc_core::channelz::BaseNode::EntityType::kListenSocket)) {
-    return nullptr;
-  }
-  grpc_core::Json json = grpc_core::Json::FromObject({
-      {"socket", socket_node->RenderJson()},
-  });
-  return grpc_core::channelz::ApplyHacks(grpc_core::JsonDump(json).c_str());
-}

data/src/core/channelz/channelz_registry.h

@@ -95,9 +95,6 @@ class ChannelzRegistry final {
             start_socket_id);
   }
 
-  static std::string GetTopChannelsJson(intptr_t start_channel_id);
-  static std::string GetServersJson(intptr_t start_server_id);
-
   // Returns the allocated JSON string that represents the proto
   // GetServersResponse as per channelz.proto.
   static auto GetServers(intptr_t start_server_id) {
@@ -106,6 +103,11 @@ class ChannelzRegistry final {
             start_server_id);
   }
 
+  static std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool> GetChildren(
+      const BaseNode* parent, intptr_t start_node, size_t max_results) {
+    return Default()->InternalGetChildren(parent, start_node, max_results);
+  }
+
   static std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool>
   GetChildrenOfType(intptr_t start_node, const BaseNode* parent,
                     BaseNode::EntityType type, size_t max_results) {
@@ -215,6 +217,15 @@ class ChannelzRegistry final {
       absl::FunctionRef<bool(const BaseNode*)> discriminator,
       size_t max_results);
 
+  std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool>
+  InternalGetChildren(const BaseNode* parent, intptr_t start_node,
+                      size_t max_results) {
+    return QueryNodes(
+        start_node,
+        [parent](const BaseNode* n) { return n->HasParent(parent); },
+        max_results);
+  }
+
   std::tuple<std::vector<WeakRefCountedPtr<BaseNode>>, bool>
   InternalGetChildrenOfType(intptr_t start_node, const BaseNode* parent,
                             BaseNode::EntityType type, size_t max_results) {
@@ -273,10 +284,6 @@ class ChannelzRegistry final {
   size_t max_orphaned_per_shard_;
 };
 
-// `additionalInfo` section is not yet in the protobuf format, so we
-// provide a utility to strip it for compatibility.
-std::string StripAdditionalInfoFromJson(absl::string_view json);
-
 }  // namespace channelz
 }  // namespace grpc_core
 

data/src/core/channelz/property_list.cc

@@ -119,15 +119,13 @@ grpc_channelz_v2_PropertyValue* ToUpbProto(const PropertyValue& value,
 void PropertyList::SetInternal(absl::string_view key,
                                std::optional<PropertyValue> value) {
   if (value.has_value()) {
-    property_list_.insert_or_assign(key, *std::move(value));
-  } else {
-    property_list_.erase(std::string(key));
+    property_list_.emplace_back(std::string(key), *std::move(value));
   }
 }
 
 PropertyList& PropertyList::Merge(PropertyList other) {
   for (auto& [key, value] : other.property_list_) {
-    SetInternal(key, value);
+    SetInternal(key, std::move(value));
   }
   return *this;
 }
@@ -135,16 +133,24 @@ PropertyList& PropertyList::Merge(PropertyList other) {
 Json::Object PropertyList::TakeJsonObject() {
   Json::Object json;
   for (auto& [key, value] : property_list_) {
-    json.emplace(key, ToJson(value));
+    json.emplace(std::string(key), ToJson(value));
   }
   return json;
 }
 
 void PropertyList::FillUpbProto(grpc_channelz_v2_PropertyList* proto,
                                 upb_Arena* arena) {
+  auto* elements = grpc_channelz_v2_PropertyList_resize_properties(
+      proto, property_list_.size(), arena);
+  size_t i = 0;
   for (auto& [key, value] : property_list_) {
-    grpc_channelz_v2_PropertyList_properties_set(
-        proto, StdStringToUpbString(key), ToUpbProto(value, arena), arena);
+    auto* element = grpc_channelz_v2_PropertyList_Element_new(arena);
+    grpc_channelz_v2_PropertyList_Element_set_key(
+        element, CopyStdStringToUpbString(key, arena));
+    grpc_channelz_v2_PropertyList_Element_set_value(element,
+                                                    ToUpbProto(value, arena));
+    elements[i] = element;
+    i++;
   }
 }
 
@@ -244,28 +250,18 @@ void PropertyGrid::SetInternal(absl::string_view column, absl::string_view row,
 PropertyGrid& PropertyGrid::SetColumn(absl::string_view column,
                                       PropertyList values) {
   int c = GetIndex(columns_, column);
-  std::vector<std::string> keys;
-  for (const auto& [key, value] : values.property_list_) {
-    keys.push_back(key);
-  }
-  std::sort(keys.begin(), keys.end());
-  for (const auto& key : keys) {
-    grid_.emplace(std::pair(c, GetIndex(rows_, key)),
-                  std::move(values.property_list_.at(key)));
+  for (auto& [key, value] : values.property_list_) {
+    grid_.emplace(std::pair(c, GetIndex(rows_, std::move(key))),
+                  std::move(value));
   }
   return *this;
 }
 
 PropertyGrid& PropertyGrid::SetRow(absl::string_view row, PropertyList values) {
   int r = GetIndex(rows_, row);
-  std::vector<std::string> keys;
-  for (const auto& [key, value] : values.property_list_) {
-    keys.push_back(key);
-  }
-  std::sort(keys.begin(), keys.end());
-  for (const auto& key : keys) {
-    grid_.emplace(std::pair(GetIndex(columns_, key), r),
-                  std::move(values.property_list_.at(key)));
+  for (auto& [key, value] : values.property_list_) {
+    grid_.emplace(std::pair(GetIndex(columns_, std::move(key)), r),
+                  std::move(value));
   }
   return *this;
 }

data/src/core/channelz/property_list.h

@@ -17,6 +17,8 @@
 
 #include <cstddef>
 #include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
@@ -139,7 +141,7 @@ class PropertyList final : public OtherPropertyValue {
   friend class PropertyGrid;
   friend class PropertyTable;
 
-  absl::flat_hash_map<std::string, PropertyValue> property_list_;
+  std::vector<std::pair<std::string, PropertyValue>> property_list_;
 };
 
 // PropertyGrid is much the same as PropertyList, but it is two dimensional.