grpc 1.63.0 → 1.66.0

data/include/grpc/impl/channel_arg_names.h

@@ -67,9 +67,6 @@
    application will see the compressed message in the byte buffer. */
 #define GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION \
   "grpc.per_message_decompression"
-/** Enable/disable support for deadline checking. Defaults to 1, unless
-    GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0 */
-#define GRPC_ARG_ENABLE_DEADLINE_CHECKS "grpc.enable_deadline_checking"
 /** Initial stream ID for http2 transports. Int valued. */
 #define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \
   "grpc.http2.initial_sequence_number"
@@ -114,9 +111,11 @@
   "grpc.server_max_unrequested_time_in_server"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
-/** How many pings can the client send before needing to send a
-   data/header frame? (0 indicates that an infinite number of
-   pings can be sent without sending a data frame or header frame) */
+/** How many pings can the client send before needing to send a data/header
+   frame? (0 indicates that an infinite number of pings can be sent without
+   sending a data frame or header frame).
+   If experiment "max_pings_wo_data_throttle" is enabled, instead of pings being
+   completely blocked, they are throttled. */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
   "grpc.http2.max_pings_without_data"
 /** How many misbehaving pings the server can bear before sending goaway and
@@ -399,6 +398,8 @@
  * If unspecified, it is unlimited */
 #define GRPC_ARG_MAX_ALLOWED_INCOMING_CONNECTIONS \
   "grpc.max_allowed_incoming_connections"
+/** Configure per-channel or per-server stats plugins. */
+#define GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS "grpc.experimental.stats_plugins"
 /** \} */
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/include/grpc/module.modulemap

@@ -6,6 +6,7 @@ header "byte_buffer.h"
   header "byte_buffer_reader.h"
   header "census.h"
   header "compression.h"
+  header "credentials.h"
   header "fork.h"
   header "grpc.h"
   header "grpc_audit_logging.h"
@@ -37,6 +38,7 @@ header "byte_buffer.h"
   header "impl/propagation_bits.h"
   header "impl/slice_type.h"
   header "load_reporting.h"
+  header "passive_listener.h"
   header "slice.h"
   header "slice_buffer.h"
   header "status.h"

data/include/grpc/passive_listener.h

@@ -0,0 +1,62 @@
+// Copyright 2024 The 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_PASSIVE_LISTENER_H
+#define GRPC_PASSIVE_LISTENER_H
+
+#include <memory>
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+// #include <grpc/support/port_platform.h>
+
+namespace grpc_core {
+class Server;
+
+namespace experimental {
+class PassiveListenerImpl;
+
+/// -- EXPERIMENTAL API --
+/// Interface for used for Server Endpoint injection.
+class PassiveListener {
+ public:
+  virtual ~PassiveListener() = default;
+  /// -- EXPERIMENTAL API --
+  ///
+  /// Takes an Endpoint for an established connection, and treats it as if the
+  /// connection had been accepted by the server.
+  ///
+  /// The server must be started before endpoints can be accepted.
+  virtual absl::Status AcceptConnectedEndpoint(
+      std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+          endpoint) = 0;
+
+  /// -- EXPERIMENTAL API --
+  ///
+  /// Takes a connected file descriptor, and treats it as if the server had
+  /// accepted the connection itself.
+  ///
+  /// Returns a failure status if the server's active EventEngine does not
+  /// support Endpoint creation from fds.
+  virtual absl::Status AcceptConnectedFd(int fd) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_core
+
+absl::Status grpc_server_add_passive_listener(
+    grpc_core::Server* server, grpc_server_credentials* credentials,
+    std::shared_ptr<grpc_core::experimental::PassiveListenerImpl>
+        passive_listener);
+
+#endif /* GRPC_PASSIVE_LISTENER_H */

data/include/grpc/support/log.h

@@ -28,15 +28,10 @@
 extern "C" {
 #endif
 
-/** GPR log API.
-
-   Usage (within grpc):
-
-   int argument1 = 3;
-   char* argument2 = "hello";
-   gpr_log(GPR_DEBUG, "format string %d", argument1);
-   gpr_log(GPR_INFO, "hello world");
-   gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */
+/**
+ * Logging functions in this file are deprecated.
+ * Please use absl ABSL_LOG instead.
+ */
 
 /** The severity of a log message - use the #defines below when calling into
    gpr_log to additionally supply file and line data */
@@ -46,9 +41,6 @@ typedef enum gpr_log_severity {
   GPR_LOG_SEVERITY_ERROR
 } gpr_log_severity;
 
-/** Returns a string representation of the log severity */
-GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity);
-
 /** Macros to build log contexts at various severity levels */
 #define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG
 #define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO
@@ -65,7 +57,7 @@ GPRAPI void gpr_log_message(const char* file, int line,
                             gpr_log_severity severity, const char* message);
 
 /** Set global log verbosity */
-GPRAPI void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print);
+GPRAPI void gpr_set_log_verbosity(gpr_log_severity deprecated_setting);
 
 GPRAPI void gpr_log_verbosity_init(void);
 
@@ -82,28 +74,8 @@ struct gpr_log_func_args {
 typedef struct gpr_log_func_args gpr_log_func_args;
 
 typedef void (*gpr_log_func)(gpr_log_func_args* args);
-GPRAPI void gpr_set_log_function(gpr_log_func func);
-
-GPRAPI void gpr_assertion_failed(const char* filename, int line,
-                                 const char* message) GPR_ATTRIBUTE_NORETURN;
-
-/** abort() the process if x is zero, having written a line to the log.
-
-   Intended for internal invariants.  If the error can be recovered from,
-   without the possibility of corruption, or might best be reflected via
-   an exception in a higher-level language, consider returning error code.  */
-#define GPR_ASSERT(x)                               \
-  do {                                              \
-    if (GPR_UNLIKELY(!(x))) {                       \
-      gpr_assertion_failed(__FILE__, __LINE__, #x); \
-    }                                               \
-  } while (0)
-
-#ifndef NDEBUG
-#define GPR_DEBUG_ASSERT(x) GPR_ASSERT(x)
-#else
-#define GPR_DEBUG_ASSERT(x)
-#endif
+
+GPRAPI void gpr_set_log_function(gpr_log_func deprecated_setting);
 
 #ifdef __cplusplus
 }

data/include/grpc/support/metrics.h

@@ -17,6 +17,7 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {
@@ -26,9 +27,10 @@ namespace experimental {
 // plugins.
 class StatsPluginChannelScope {
  public:
-  StatsPluginChannelScope(absl::string_view target,
-                          absl::string_view default_authority)
-      : target_(target), default_authority_(default_authority) {}
+  StatsPluginChannelScope(
+      absl::string_view target, absl::string_view default_authority,
+      const grpc_event_engine::experimental::EndpointConfig& args)
+      : target_(target), default_authority_(default_authority), args_(args) {}
 
   /// Returns the target used for creating the channel in the canonical form.
   /// (Canonicalized target definition -
@@ -36,13 +38,22 @@ class StatsPluginChannelScope {
   absl::string_view target() const { return target_; }
   /// Returns the default authority for the channel.
   absl::string_view default_authority() const { return default_authority_; }
+  /// Returns channel arguments.  THIS METHOD IS EXPERIMENTAL.
+  // TODO(roth, ctiller, yashkt): Find a better representation for
+  // channel args before de-experimentalizing this API.
+  const grpc_event_engine::experimental::EndpointConfig& experimental_args()
+      const {
+    return args_;
+  }
 
  private:
   // Disable copy constructor and copy-assignment operator.
   StatsPluginChannelScope(const StatsPluginChannelScope&) = delete;
   StatsPluginChannelScope& operator=(const StatsPluginChannelScope&) = delete;
+
   absl::string_view target_;
   absl::string_view default_authority_;
+  const grpc_event_engine::experimental::EndpointConfig& args_;
 };
 
 }  // namespace experimental

data/include/grpc/support/port_platform.h

@@ -272,6 +272,9 @@
 #define GPR_PLATFORM_STRING "ios"
 #define GPR_CPU_IPHONE 1
 #define GRPC_CFSTREAM 1
+#ifndef GRPC_IOS_EVENT_ENGINE_CLIENT
+#define GRPC_IOS_EVENT_ENGINE_CLIENT 1
+#endif /* GRPC_IOS_EVENT_ENGINE_CLIENT */
 /* the c-ares resolver isn't safe to enable on iOS */
 #define GRPC_ARES 0
 #else /* TARGET_OS_IPHONE */
@@ -743,6 +746,22 @@ extern void gpr_unreachable_code(const char* reason, const char* file,
 #endif
 #endif /* GPR_ATTRIBUTE_NOINLINE */
 
+#ifndef GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#ifdef __cplusplus
+#if GPR_HAS_CPP_ATTRIBUTE(clang::always_inline)
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION [[clang::always_inline]]
+#elif GPR_HAS_ATTRIBUTE(always_inline)
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION __attribute__((always_inline))
+#else
+// TODO(ctiller): add __forceinline for MSVC
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#endif
+#else
+// Disable for C code
+#define GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+#endif
+#endif /* GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION */
+
 #ifndef GPR_NO_UNIQUE_ADDRESS
 #if GPR_HAS_CPP_ATTRIBUTE(no_unique_address)
 #define GPR_NO_UNIQUE_ADDRESS [[no_unique_address]]
@@ -817,6 +836,12 @@ extern void gpr_unreachable_code(const char* reason, const char* file,
 #endif /* __GPR_WINDOWS */
 #endif /* GRPC_ALLOW_EXCEPTIONS */
 
+#ifdef __has_builtin
+#define GRPC_HAS_BUILTIN(a) __has_builtin(a)
+#else
+#define GRPC_HAS_BUILTIN(a) 0
+#endif
+
 /* Use GPR_LIKELY only in cases where you are sure that a certain outcome is the
  * most likely. Ideally, also collect performance numbers to justify the claim.
  */

data/src/core/{lib/channel → channelz}/channel_trace.cc

@@ -16,9 +16,7 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/channel/channel_trace.h"
+#include "src/core/channelz/channel_trace.h"
 
 #include <memory>
 #include <utility>
@@ -27,47 +25,79 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 namespace channelz {
 
+//
+// ChannelTrace::TraceEvent
+//
+
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
                                      RefCountedPtr<BaseNode> referenced_entity)
-    : severity_(severity),
+    : timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
+      severity_(severity),
       data_(data),
-      timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
-      next_(nullptr),
-      referenced_entity_(std::move(referenced_entity)),
-      memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
+      memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)),
+      referenced_entity_(std::move(referenced_entity)) {}
 
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data)
-    : severity_(severity),
-      data_(data),
-      timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
-      next_(nullptr),
-      memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
+    : TraceEvent(severity, data, nullptr) {}
 
 ChannelTrace::TraceEvent::~TraceEvent() { CSliceUnref(data_); }
 
-ChannelTrace::ChannelTrace(size_t max_event_memory)
-    : num_events_logged_(0),
-      event_list_memory_usage_(0),
-      max_event_memory_(max_event_memory),
-      head_trace_(nullptr),
-      tail_trace_(nullptr) {
-  if (max_event_memory_ == 0) {
-    return;  // tracing is disabled if max_event_memory_ == 0
+namespace {
+
+const char* SeverityString(ChannelTrace::Severity severity) {
+  switch (severity) {
+    case ChannelTrace::Severity::Info:
+      return "CT_INFO";
+    case ChannelTrace::Severity::Warning:
+      return "CT_WARNING";
+    case ChannelTrace::Severity::Error:
+      return "CT_ERROR";
+    default:
+      GPR_UNREACHABLE_CODE(return "CT_UNKNOWN");
+  }
+}
+
+}  // anonymous namespace
+
+Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
+  char* description = grpc_slice_to_c_string(data_);
+  Json::Object object = {
+      {"description", Json::FromString(description)},
+      {"severity", Json::FromString(SeverityString(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::FromObject({
+        {(is_channel ? "channelId" : "subchannelId"),
+         Json::FromString(absl::StrCat(referenced_entity_->uuid()))},
+    });
   }
-  gpr_mu_init(&tracer_mu_);
-  time_created_ = Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME);
+  return Json::FromObject(std::move(object));
 }
 
+//
+// ChannelTrace
+//
+
+ChannelTrace::ChannelTrace(size_t max_event_memory)
+    : max_event_memory_(max_event_memory),
+      time_created_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)) {}
+
 ChannelTrace::~ChannelTrace() {
   if (max_event_memory_ == 0) {
     return;  // tracing is disabled if max_event_memory_ == 0
@@ -78,10 +108,10 @@ ChannelTrace::~ChannelTrace() {
     it = it->next();
     delete to_free;
   }
-  gpr_mu_destroy(&tracer_mu_);
 }
 
 void ChannelTrace::AddTraceEventHelper(TraceEvent* new_trace_event) {
+  MutexLock lock(&mu_);
   ++num_events_logged_;
   // first event case
   if (head_trace_ == nullptr) {
@@ -122,43 +152,6 @@ void ChannelTrace::AddTraceEventWithReference(
       new TraceEvent(severity, data, std::move(referenced_entity)));
 }
 
-namespace {
-
-const char* severity_string(ChannelTrace::Severity severity) {
-  switch (severity) {
-    case ChannelTrace::Severity::Info:
-      return "CT_INFO";
-    case ChannelTrace::Severity::Warning:
-      return "CT_WARNING";
-    case ChannelTrace::Severity::Error:
-      return "CT_ERROR";
-    default:
-      GPR_UNREACHABLE_CODE(return "CT_UNKNOWN");
-  }
-}
-
-}  // anonymous namespace
-
-Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
-  char* description = grpc_slice_to_c_string(data_);
-  Json::Object object = {
-      {"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::FromObject({
-        {(is_channel ? "channelId" : "subchannelId"),
-         Json::FromString(absl::StrCat(referenced_entity_->uuid()))},
-    });
-  }
-  return Json::FromObject(std::move(object));
-}
-
 Json ChannelTrace::RenderJson() const {
   // Tracing is disabled if max_event_memory_ == 0.
   if (max_event_memory_ == 0) {
@@ -168,6 +161,7 @@ Json ChannelTrace::RenderJson() const {
       {"creationTimestamp",
        Json::FromString(gpr_format_timespec(time_created_))},
   };
+  MutexLock lock(&mu_);
   if (num_events_logged_ > 0) {
     object["numEventsLogged"] =
         Json::FromString(absl::StrCat(num_events_logged_));

data/src/core/{lib/channel → channelz}/channel_trace.h

@@ -16,20 +16,21 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_TRACE_H
-#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_TRACE_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_CHANNELZ_CHANNEL_TRACE_H
+#define GRPC_SRC_CORE_CHANNELZ_CHANNEL_TRACE_H
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include "absl/base/thread_annotations.h"
+
 #include <grpc/slice.h>
-#include <grpc/support/sync.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/json/json.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -111,28 +112,29 @@ class ChannelTrace {
     size_t memory_usage() const { return memory_usage_; }
 
    private:
-    Severity severity_;
-    grpc_slice data_;
-    gpr_timespec timestamp_;
-    TraceEvent* next_;
+    const gpr_timespec timestamp_;
+    const Severity severity_;
+    const grpc_slice data_;
+    const size_t memory_usage_;
     // the tracer object for the (sub)channel that this trace event refers to.
-    RefCountedPtr<BaseNode> referenced_entity_;
-    size_t memory_usage_;
+    const RefCountedPtr<BaseNode> referenced_entity_;
+    TraceEvent* next_ = nullptr;
   };  // TraceEvent
 
   // Internal helper to add and link in a trace event
   void AddTraceEventHelper(TraceEvent* new_trace_event);
 
-  gpr_mu tracer_mu_;
-  uint64_t num_events_logged_;
-  size_t event_list_memory_usage_;
-  size_t max_event_memory_;
-  TraceEvent* head_trace_;
-  TraceEvent* tail_trace_;
-  gpr_timespec time_created_;
+  const size_t max_event_memory_;
+  const gpr_timespec time_created_;
+
+  mutable Mutex mu_;
+  uint64_t num_events_logged_ ABSL_GUARDED_BY(mu_) = 0;
+  size_t event_list_memory_usage_ ABSL_GUARDED_BY(mu_) = 0;
+  TraceEvent* head_trace_ ABSL_GUARDED_BY(mu_) = nullptr;
+  TraceEvent* tail_trace_ ABSL_GUARDED_BY(mu_) = nullptr;
 };
 
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_TRACE_H
+#endif  // GRPC_SRC_CORE_CHANNELZ_CHANNEL_TRACE_H

data/src/core/{lib/channel → channelz}/channelz.cc

@@ -16,14 +16,13 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/channel/channelz.h"
+#include "src/core/channelz/channelz.h"
 
 #include <algorithm>
 #include <atomic>
 #include <cstdint>
 
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
@@ -31,18 +30,19 @@
 
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channelz_registry.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/channel/channelz_registry.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.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"
+#include "src/core/util/json/json_writer.h"
+#include "src/core/util/string.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 namespace channelz {
@@ -263,6 +263,68 @@ void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
   child_subchannels_.erase(child_uuid);
 }
 
+//
+// SubchannelNode
+//
+
+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) {}
+
+SubchannelNode::~SubchannelNode() {}
+
+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);
+}
+
+Json SubchannelNode::RenderJson() {
+  // Create and fill the data child.
+  grpc_connectivity_state state =
+      connectivity_state_.load(std::memory_order_relaxed);
+  Json::Object data = {
+      {"state", Json::FromObject({
+                    {"state", Json::FromString(ConnectivityStateName(state))},
+                })},
+      {"target", Json::FromString(target_)},
+  };
+  // Fill in the channel trace if applicable
+  Json trace_json = trace_.RenderJson();
+  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::FromObject({
+                  {"subchannelId", Json::FromString(absl::StrCat(uuid()))},
+              })},
+      {"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) {
+    object["socketRef"] = Json::FromArray({
+        Json::FromObject({
+            {"socketId", Json::FromString(absl::StrCat(child_socket->uuid()))},
+            {"name", Json::FromString(child_socket->name())},
+        }),
+    });
+  }
+  return Json::FromObject(object);
+}
+
 //
 // ServerNode
 //
@@ -294,8 +356,8 @@ void ServerNode::RemoveChildListenSocket(intptr_t child_uuid) {
 
 std::string ServerNode::RenderServerSockets(intptr_t start_socket_id,
                                             intptr_t max_results) {
-  GPR_ASSERT(start_socket_id >= 0);
-  GPR_ASSERT(max_results >= 0);
+  CHECK_GE(start_socket_id, 0);
+  CHECK_GE(max_results, 0);
   // If user does not set max_results, we choose 500.
   size_t pagination_limit = max_results == 0 ? 500 : max_results;
   Json::Object object;