grpc 1.63.2 → 1.64.0.pre1

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"

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"

data/include/grpc/support/log.h

@@ -102,7 +102,7 @@ GPRAPI void gpr_assertion_failed(const char* filename, int line,
 #ifndef NDEBUG
 #define GPR_DEBUG_ASSERT(x) GPR_ASSERT(x)
 #else
-#define GPR_DEBUG_ASSERT(x)
+#define GPR_DEBUG_ASSERT(x) GPR_ASSERT(true || (x))
 #endif
 
 #ifdef __cplusplus

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,8 +25,9 @@
 
 #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/channelz/channelz.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/slice/slice.h"
@@ -37,37 +36,68 @@
 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,19 +16,20 @@
 //
 //
 
-#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/gprpp/sync.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -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,12 +30,13 @@
 
 #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"
@@ -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;

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

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H
-#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_CHANNELZ_CHANNELZ_H
+#define GRPC_SRC_CORE_CHANNELZ_CHANNELZ_H
 
 #include <stddef.h>
 
@@ -30,14 +28,16 @@
 #include <string>
 #include <utility>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_trace.h"
+#include "src/core/channelz/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/per_cpu.h"
@@ -246,6 +246,45 @@ class ChannelNode final : public BaseNode {
   std::set<intptr_t> child_subchannels_;
 };
 
+// Handles channelz bookkeeping for subchannels
+class SubchannelNode final : public BaseNode {
+ public:
+  SubchannelNode(std::string target_address, size_t channel_tracer_max_nodes);
+  ~SubchannelNode() override;
+
+  // 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 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(); }
+
+ private:
+  std::atomic<grpc_connectivity_state> connectivity_state_{GRPC_CHANNEL_IDLE};
+  Mutex socket_mu_;
+  RefCountedPtr<SocketNode> child_socket_ ABSL_GUARDED_BY(socket_mu_);
+  std::string target_;
+  CallCountingHelper call_counter_;
+  ChannelTrace trace_;
+};
+
 // Handles channelz bookkeeping for servers
 class ServerNode final : public BaseNode {
  public:
@@ -381,4 +420,4 @@ class ListenSocketNode final : public BaseNode {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_H
+#endif  // GRPC_SRC_CORE_CHANNELZ_CHANNELZ_H

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

@@ -16,9 +16,7 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/channel/channelz_registry.h"
+#include "src/core/channelz/channelz_registry.h"
 
 #include <algorithm>
 #include <cstdint>
@@ -26,12 +24,15 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channelz.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/json/json.h"
@@ -57,9 +58,9 @@ void ChannelzRegistry::InternalRegister(BaseNode* node) {
 }
 
 void ChannelzRegistry::InternalUnregister(intptr_t uuid) {
-  GPR_ASSERT(uuid >= 1);
+  CHECK_GE(uuid, 1);
   MutexLock lock(&mu_);
-  GPR_ASSERT(uuid <= uuid_generator_);
+  CHECK(uuid <= uuid_generator_);
   node_map_.erase(uuid);
 }
 

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

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
-#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_CHANNELZ_CHANNELZ_REGISTRY_H
+#define GRPC_SRC_CORE_CHANNELZ_CHANNELZ_REGISTRY_H
 
 #include <cstdint>
 #include <map>
@@ -27,7 +25,9 @@
 
 #include "absl/base/thread_annotations.h"
 
-#include "src/core/lib/channel/channelz.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -99,4 +99,4 @@ class ChannelzRegistry final {
 }  // namespace channelz
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNELZ_REGISTRY_H
+#endif  // GRPC_SRC_CORE_CHANNELZ_CHANNELZ_REGISTRY_H