grpc 1.54.2 → 1.56.0.pre3

data/src/core/lib/channel/channel_trace.cc

@@ -21,10 +21,12 @@
 #include "src/core/lib/channel/channel_trace.h"
 
 #include <algorithm>
-#include <string>
 #include <utility>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
+#include <grpc/support/json.h>
 
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
@@ -140,21 +142,21 @@ const char* severity_string(ChannelTrace::Severity severity) {
 Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
   char* description = grpc_slice_to_c_string(data_);
   Json::Object object = {
-      {"description", description},
-      {"severity", severity_string(severity_)},
-      {"timestamp", gpr_format_timespec(timestamp_)},
+      {"description", Json::FromString(description)},
+      {"severity", Json::FromString(severity_string(severity_))},
+      {"timestamp", Json::FromString(gpr_format_timespec(timestamp_))},
   };
   gpr_free(description);
   if (referenced_entity_ != nullptr) {
     const bool is_channel =
         (referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
          referenced_entity_->type() == BaseNode::EntityType::kInternalChannel);
-    object[is_channel ? "channelRef" : "subchannelRef"] = Json::Object{
+    object[is_channel ? "channelRef" : "subchannelRef"] = Json::FromObject({
         {(is_channel ? "channelId" : "subchannelId"),
-         std::to_string(referenced_entity_->uuid())},
-    };
+         Json::FromString(absl::StrCat(referenced_entity_->uuid()))},
+    });
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 Json ChannelTrace::RenderJson() const {
@@ -163,10 +165,12 @@ Json ChannelTrace::RenderJson() const {
     return Json();  // JSON null
   }
   Json::Object object = {
-      {"creationTimestamp", gpr_format_timespec(time_created_)},
+      {"creationTimestamp",
+       Json::FromString(gpr_format_timespec(time_created_))},
   };
   if (num_events_logged_ > 0) {
-    object["numEventsLogged"] = std::to_string(num_events_logged_);
+    object["numEventsLogged"] =
+        Json::FromString(absl::StrCat(num_events_logged_));
   }
   // Only add in the event list if it is non-empty.
   if (head_trace_ != nullptr) {
@@ -174,9 +178,9 @@ Json ChannelTrace::RenderJson() const {
     for (TraceEvent* it = head_trace_; it != nullptr; it = it->next()) {
       array.emplace_back(it->RenderTraceEvent());
     }
-    object["events"] = std::move(array);
+    object["events"] = Json::FromArray(std::move(array));
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 }  // namespace channelz

data/src/core/lib/channel/channelz.cc

@@ -22,12 +22,14 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstdint>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/cpu.h>
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -37,8 +39,8 @@
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -59,73 +61,94 @@ BaseNode::~BaseNode() { ChannelzRegistry::Unregister(uuid_); }
 
 std::string BaseNode::RenderJsonString() {
   Json json = RenderJson();
-  return json.Dump();
+  return JsonDump(json);
 }
 
 //
 // CallCountingHelper
 //
 
-CallCountingHelper::CallCountingHelper() {
-  num_cores_ = std::max(1u, gpr_cpu_num_cores());
-  per_cpu_counter_data_storage_.reserve(num_cores_);
-  for (size_t i = 0; i < num_cores_; ++i) {
-    per_cpu_counter_data_storage_.emplace_back();
+void CallCountingHelper::RecordCallStarted() {
+  calls_started_.fetch_add(1, std::memory_order_relaxed);
+  last_call_started_cycle_.store(gpr_get_cycle_counter(),
+                                 std::memory_order_relaxed);
+}
+
+void CallCountingHelper::RecordCallFailed() {
+  calls_failed_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void CallCountingHelper::RecordCallSucceeded() {
+  calls_succeeded_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void CallCountingHelper::PopulateCallCounts(Json::Object* json) {
+  auto calls_started = calls_started_.load(std::memory_order_relaxed);
+  auto calls_succeeded = calls_succeeded_.load(std::memory_order_relaxed);
+  auto calls_failed = calls_failed_.load(std::memory_order_relaxed);
+  auto last_call_started_cycle =
+      last_call_started_cycle_.load(std::memory_order_relaxed);
+  if (calls_started != 0) {
+    (*json)["callsStarted"] = Json::FromString(absl::StrCat(calls_started));
+    gpr_timespec ts = gpr_convert_clock_type(
+        gpr_cycle_counter_to_time(last_call_started_cycle), GPR_CLOCK_REALTIME);
+    (*json)["lastCallStartedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
+  }
+  if (calls_succeeded != 0) {
+    (*json)["callsSucceeded"] = Json::FromString(absl::StrCat(calls_succeeded));
+  }
+  if (calls_failed != 0) {
+    (*json)["callsFailed"] = Json::FromString(absl::StrCat(calls_failed));
   }
 }
 
-void CallCountingHelper::RecordCallStarted() {
-  AtomicCounterData& data =
-      per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()];
+//
+// PerCpuCallCountingHelper
+//
+
+void PerCpuCallCountingHelper::RecordCallStarted() {
+  auto& data = per_cpu_data_.this_cpu();
   data.calls_started.fetch_add(1, std::memory_order_relaxed);
   data.last_call_started_cycle.store(gpr_get_cycle_counter(),
                                      std::memory_order_relaxed);
 }
 
-void CallCountingHelper::RecordCallFailed() {
-  per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_failed.fetch_add(1, std::memory_order_relaxed);
+void PerCpuCallCountingHelper::RecordCallFailed() {
+  per_cpu_data_.this_cpu().calls_failed.fetch_add(1, std::memory_order_relaxed);
 }
 
-void CallCountingHelper::RecordCallSucceeded() {
-  per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_succeeded.fetch_add(1, std::memory_order_relaxed);
-}
-
-void CallCountingHelper::CollectData(CounterData* out) {
-  for (size_t core = 0; core < num_cores_; ++core) {
-    AtomicCounterData& data = per_cpu_counter_data_storage_[core];
-
-    out->calls_started += data.calls_started.load(std::memory_order_relaxed);
-    out->calls_succeeded +=
-        per_cpu_counter_data_storage_[core].calls_succeeded.load(
-            std::memory_order_relaxed);
-    out->calls_failed += per_cpu_counter_data_storage_[core].calls_failed.load(
-        std::memory_order_relaxed);
-    const gpr_cycle_counter last_call =
-        per_cpu_counter_data_storage_[core].last_call_started_cycle.load(
-            std::memory_order_relaxed);
-    if (last_call > out->last_call_started_cycle) {
-      out->last_call_started_cycle = last_call;
-    }
-  }
+void PerCpuCallCountingHelper::RecordCallSucceeded() {
+  per_cpu_data_.this_cpu().calls_succeeded.fetch_add(1,
+                                                     std::memory_order_relaxed);
 }
 
-void CallCountingHelper::PopulateCallCounts(Json::Object* json) {
-  CounterData data;
-  CollectData(&data);
-  if (data.calls_started != 0) {
-    (*json)["callsStarted"] = std::to_string(data.calls_started);
+void PerCpuCallCountingHelper::PopulateCallCounts(Json::Object* json) {
+  int64_t calls_started = 0;
+  int64_t calls_succeeded = 0;
+  int64_t calls_failed = 0;
+  gpr_cycle_counter last_call_started_cycle = 0;
+  for (const auto& cpu : per_cpu_data_) {
+    calls_started += cpu.calls_started.load(std::memory_order_relaxed);
+    calls_succeeded += cpu.calls_succeeded.load(std::memory_order_relaxed);
+    calls_failed += cpu.calls_failed.load(std::memory_order_relaxed);
+    last_call_started_cycle =
+        std::max(last_call_started_cycle,
+                 cpu.last_call_started_cycle.load(std::memory_order_relaxed));
+  }
+
+  if (calls_started != 0) {
+    (*json)["callsStarted"] = Json::FromString(absl::StrCat(calls_started));
     gpr_timespec ts = gpr_convert_clock_type(
-        gpr_cycle_counter_to_time(data.last_call_started_cycle),
-        GPR_CLOCK_REALTIME);
-    (*json)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
+        gpr_cycle_counter_to_time(last_call_started_cycle), GPR_CLOCK_REALTIME);
+    (*json)["lastCallStartedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
-  if (data.calls_succeeded != 0) {
-    (*json)["callsSucceeded"] = std::to_string(data.calls_succeeded);
+  if (calls_succeeded != 0) {
+    (*json)["callsSucceeded"] = Json::FromString(absl::StrCat(calls_succeeded));
   }
-  if (data.calls_failed) {
-    (*json)["callsFailed"] = std::to_string(data.calls_failed);
+  if (calls_failed != 0) {
+    (*json)["callsFailed"] = Json::FromString(absl::StrCat(calls_failed));
   }
 }
 
@@ -160,7 +183,7 @@ const char* ChannelNode::GetChannelConnectivityStateChangeString(
 
 Json ChannelNode::RenderJson() {
   Json::Object data = {
-      {"target", target_},
+      {"target", Json::FromString(target_)},
   };
   // Connectivity state.
   // If low-order bit is on, then the field is set.
@@ -168,29 +191,28 @@ Json ChannelNode::RenderJson() {
   if ((state_field & 1) != 0) {
     grpc_connectivity_state state =
         static_cast<grpc_connectivity_state>(state_field >> 1);
-    data["state"] = Json::Object{
-        {"state", ConnectivityStateName(state)},
-    };
+    data["state"] = Json::FromObject({
+        {"state", Json::FromString(ConnectivityStateName(state))},
+    });
   }
   // Fill in the channel trace if applicable.
   Json trace_json = trace_.RenderJson();
-  if (trace_json.type() != Json::Type::JSON_NULL) {
+  if (trace_json.type() != Json::Type::kNull) {
     data["trace"] = std::move(trace_json);
   }
   // Ask CallCountingHelper to populate call count data.
   call_counter_.PopulateCallCounts(&data);
   // Construct outer object.
   Json::Object json = {
-      {"ref",
-       Json::Object{
-           {"channelId", std::to_string(uuid())},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"channelId", Json::FromString(absl::StrCat(uuid()))},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   // Template method. Child classes may override this to add their specific
   // functionality.
   PopulateChildRefs(&json);
-  return json;
+  return Json::FromObject(std::move(json));
 }
 
 void ChannelNode::PopulateChildRefs(Json::Object* json) {
@@ -198,20 +220,20 @@ void ChannelNode::PopulateChildRefs(Json::Object* json) {
   if (!child_subchannels_.empty()) {
     Json::Array array;
     for (intptr_t subchannel_uuid : child_subchannels_) {
-      array.emplace_back(Json::Object{
-          {"subchannelId", std::to_string(subchannel_uuid)},
-      });
+      array.emplace_back(Json::FromObject({
+          {"subchannelId", Json::FromString(absl::StrCat(subchannel_uuid))},
+      }));
     }
-    (*json)["subchannelRef"] = std::move(array);
+    (*json)["subchannelRef"] = Json::FromArray(std::move(array));
   }
   if (!child_channels_.empty()) {
     Json::Array array;
     for (intptr_t channel_uuid : child_channels_) {
-      array.emplace_back(Json::Object{
-          {"channelId", std::to_string(channel_uuid)},
-      });
+      array.emplace_back(Json::FromObject({
+          {"channelId", Json::FromString(absl::StrCat(channel_uuid))},
+      }));
     }
-    (*json)["channelRef"] = std::move(array);
+    (*json)["channelRef"] = Json::FromArray(std::move(array));
   }
 }
 
@@ -285,34 +307,34 @@ std::string ServerNode::RenderServerSockets(intptr_t start_socket_id,
     auto it = child_sockets_.lower_bound(start_socket_id);
     for (; it != child_sockets_.end() && sockets_rendered < pagination_limit;
          ++it, ++sockets_rendered) {
-      array.emplace_back(Json::Object{
-          {"socketId", std::to_string(it->first)},
-          {"name", it->second->name()},
-      });
+      array.emplace_back(Json::FromObject({
+          {"socketId", Json::FromString(absl::StrCat(it->first))},
+          {"name", Json::FromString(it->second->name())},
+      }));
+    }
+    object["socketRef"] = Json::FromArray(std::move(array));
+    if (it == child_sockets_.end()) {
+      object["end"] = Json::FromBool(true);
     }
-    object["socketRef"] = std::move(array);
-    if (it == child_sockets_.end()) object["end"] = true;
   }
-  Json json = std::move(object);
-  return json.Dump();
+  return JsonDump(Json::FromObject(std::move(object)));
 }
 
 Json ServerNode::RenderJson() {
   Json::Object data;
   // Fill in the channel trace if applicable.
   Json trace_json = trace_.RenderJson();
-  if (trace_json.type() != Json::Type::JSON_NULL) {
+  if (trace_json.type() != Json::Type::kNull) {
     data["trace"] = std::move(trace_json);
   }
   // Ask CallCountingHelper to populate call count data.
   call_counter_.PopulateCallCounts(&data);
   // Construct top-level object.
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"serverId", std::to_string(uuid())},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"serverId", Json::FromString(absl::StrCat(uuid()))},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   // Render listen sockets.
   {
@@ -320,15 +342,15 @@ Json ServerNode::RenderJson() {
     if (!child_listen_sockets_.empty()) {
       Json::Array array;
       for (const auto& it : child_listen_sockets_) {
-        array.emplace_back(Json::Object{
-            {"socketId", std::to_string(it.first)},
-            {"name", it.second->name()},
-        });
+        array.emplace_back(Json::FromObject({
+            {"socketId", Json::FromString(absl::StrCat(it.first))},
+            {"name", Json::FromString(it.second->name())},
+        }));
       }
-      object["listenSocket"] = std::move(array);
+      object["listenSocket"] = Json::FromArray(std::move(array));
     }
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 //
@@ -338,17 +360,19 @@ Json ServerNode::RenderJson() {
 Json SocketNode::Security::Tls::RenderJson() {
   Json::Object data;
   if (type == NameType::kStandardName) {
-    data["standard_name"] = name;
+    data["standard_name"] = Json::FromString(name);
   } else if (type == NameType::kOtherName) {
-    data["other_name"] = name;
+    data["other_name"] = Json::FromString(name);
   }
   if (!local_certificate.empty()) {
-    data["local_certificate"] = absl::Base64Escape(local_certificate);
+    data["local_certificate"] =
+        Json::FromString(absl::Base64Escape(local_certificate));
   }
   if (!remote_certificate.empty()) {
-    data["remote_certificate"] = absl::Base64Escape(remote_certificate);
+    data["remote_certificate"] =
+        Json::FromString(absl::Base64Escape(remote_certificate));
   }
-  return data;
+  return Json::FromObject(std::move(data));
 }
 
 //
@@ -366,12 +390,12 @@ Json SocketNode::Security::RenderJson() {
       }
       break;
     case ModelType::kOther:
-      if (other) {
+      if (other.has_value()) {
         data["other"] = *other;
       }
       break;
   }
-  return data;
+  return Json::FromObject(std::move(data));
 }
 
 namespace {
@@ -423,32 +447,32 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
       auto address = StringToSockaddr(absl::StripPrefix(uri->path(), "/"));
       if (address.ok()) {
         std::string packed_host = grpc_sockaddr_get_packed_host(&*address);
-        (*json)[name] = Json::Object{
+        (*json)[name] = Json::FromObject({
             {"tcpip_address",
-             Json::Object{
-                 {"port", grpc_sockaddr_get_port(&*address)},
-                 {"ip_address", absl::Base64Escape(packed_host)},
-             }},
-        };
+             Json::FromObject({
+                 {"port", Json::FromString(
+                              absl::StrCat(grpc_sockaddr_get_port(&*address)))},
+                 {"ip_address",
+                  Json::FromString(absl::Base64Escape(packed_host))},
+             })},
+        });
         return;
       }
     } else if (uri->scheme() == "unix") {
-      (*json)[name] = Json::Object{
-          {"uds_address",
-           Json::Object{
-               {"filename", uri->path()},
-           }},
-      };
+      (*json)[name] = Json::FromObject({
+          {"uds_address", Json::FromObject({
+                              {"filename", Json::FromString(uri->path())},
+                          })},
+      });
       return;
     }
   }
   // Unknown address type.
-  (*json)[name] = Json::Object{
-      {"other_address",
-       Json::Object{
-           {"name", addr_str},
-       }},
-  };
+  (*json)[name] = Json::FromObject({
+      {"other_address", Json::FromObject({
+                            {"name", Json::FromString(addr_str)},
+                        })},
+  });
 }
 
 }  // namespace
@@ -490,14 +514,15 @@ Json SocketNode::RenderJson() {
   gpr_timespec ts;
   int64_t streams_started = streams_started_.load(std::memory_order_relaxed);
   if (streams_started != 0) {
-    data["streamsStarted"] = std::to_string(streams_started);
+    data["streamsStarted"] = Json::FromString(absl::StrCat(streams_started));
     gpr_cycle_counter last_local_stream_created_cycle =
         last_local_stream_created_cycle_.load(std::memory_order_relaxed);
     if (last_local_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastLocalStreamCreatedTimestamp"] =
+          Json::FromString(gpr_format_timespec(ts));
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
         last_remote_stream_created_cycle_.load(std::memory_order_relaxed);
@@ -505,49 +530,53 @@ Json SocketNode::RenderJson() {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastRemoteStreamCreatedTimestamp"] =
+          Json::FromString(gpr_format_timespec(ts));
     }
   }
   int64_t streams_succeeded =
       streams_succeeded_.load(std::memory_order_relaxed);
   if (streams_succeeded != 0) {
-    data["streamsSucceeded"] = std::to_string(streams_succeeded);
+    data["streamsSucceeded"] =
+        Json::FromString(absl::StrCat(streams_succeeded));
   }
   int64_t streams_failed = streams_failed_.load(std::memory_order_relaxed);
   if (streams_failed != 0) {
-    data["streamsFailed"] = std::to_string(streams_failed);
+    data["streamsFailed"] = Json::FromString(absl::StrCat(streams_failed));
   }
   int64_t messages_sent = messages_sent_.load(std::memory_order_relaxed);
   if (messages_sent != 0) {
-    data["messagesSent"] = std::to_string(messages_sent);
+    data["messagesSent"] = Json::FromString(absl::StrCat(messages_sent));
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_sent_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageSentTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageSentTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
   int64_t messages_received =
       messages_received_.load(std::memory_order_relaxed);
   if (messages_received != 0) {
-    data["messagesReceived"] = std::to_string(messages_received);
+    data["messagesReceived"] =
+        Json::FromString(absl::StrCat(messages_received));
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_received_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageReceivedTimestamp"] =
+        Json::FromString(gpr_format_timespec(ts));
   }
   int64_t keepalives_sent = keepalives_sent_.load(std::memory_order_relaxed);
   if (keepalives_sent != 0) {
-    data["keepAlivesSent"] = std::to_string(keepalives_sent);
+    data["keepAlivesSent"] = Json::FromString(absl::StrCat(keepalives_sent));
   }
   // Create and fill the parent object.
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", std::to_string(uuid())},
-           {"name", name()},
-       }},
-      {"data", std::move(data)},
+      {"ref", Json::FromObject({
+                  {"socketId", Json::FromString(absl::StrCat(uuid()))},
+                  {"name", Json::FromString(name())},
+              })},
+      {"data", Json::FromObject(std::move(data))},
   };
   if (security_ != nullptr &&
       security_->type != SocketNode::Security::ModelType::kUnset) {
@@ -555,7 +584,7 @@ Json SocketNode::RenderJson() {
   }
   PopulateSocketAddressJson(&object, "remote", remote_.c_str());
   PopulateSocketAddressJson(&object, "local", local_.c_str());
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 //
@@ -568,14 +597,13 @@ ListenSocketNode::ListenSocketNode(std::string local_addr, std::string name)
 
 Json ListenSocketNode::RenderJson() {
   Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", std::to_string(uuid())},
-           {"name", name()},
-       }},
+      {"ref", Json::FromObject({
+                  {"socketId", Json::FromString(absl::StrCat(uuid()))},
+                  {"name", Json::FromString(name())},
+              })},
   };
   PopulateSocketAddressJson(&object, "local", local_addr_.c_str());
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 }  // namespace channelz