grpc 1.73.0 → 1.75.0

data/src/core/call/interception_chain.h

@@ -163,11 +163,8 @@ class InterceptionChainBuilder final {
                                         RefCountedPtr<CallDestination>>;
 
   explicit InterceptionChainBuilder(ChannelArgs args,
-                                    const Blackboard* old_blackboard = nullptr,
-                                    Blackboard* new_blackboard = nullptr)
-      : args_(std::move(args)),
-        old_blackboard_(old_blackboard),
-        new_blackboard_(new_blackboard) {}
+                                    const Blackboard* blackboard = nullptr)
+      : args_(std::move(args)), blackboard_(blackboard) {}
 
   // Add a filter with a `Call` class as an inner member.
   // Call class must be one compatible with the filters described in
@@ -176,8 +173,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
   Add() {
     if (!status_.ok()) return *this;
-    auto filter = T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                    old_blackboard_, new_blackboard_});
+    auto filter =
+        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_});
     if (!filter.ok()) {
       status_ = filter.status();
       return *this;
@@ -193,8 +190,8 @@ class InterceptionChainBuilder final {
   absl::enable_if_t<std::is_base_of<Interceptor, T>::value,
                     InterceptionChainBuilder&>
   Add() {
-    AddInterceptor(T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
-                                     old_blackboard_, new_blackboard_}));
+    AddInterceptor(
+        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_}));
     return *this;
   };
 
@@ -273,8 +270,7 @@ class InterceptionChainBuilder final {
   absl::Status status_;
   std::map<size_t, size_t> filter_type_counts_;
   static std::atomic<size_t> next_filter_id_;
-  const Blackboard* old_blackboard_ = nullptr;
-  Blackboard* new_blackboard_ = nullptr;
+  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

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/channel_trace.cc

@@ -22,10 +22,12 @@
 #include <grpc/support/json.h>
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
 #include <memory>
 #include <utility>
 
 #include "absl/strings/str_cat.h"
+#include "google/protobuf/any.upb.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -33,156 +35,252 @@
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
+#include "src/core/util/upb_utils.h"
+#include "src/proto/grpc/channelz/v2/channelz.upb.h"
+#include "upb/base/string_view.h"
 
 namespace grpc_core {
 namespace channelz {
 
-//
-// ChannelTrace::TraceEvent
-//
-
-ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
-                                     RefCountedPtr<BaseNode> referenced_entity)
-    : timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
-      severity_(severity),
-      data_(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)
-    : TraceEvent(severity, data, nullptr) {}
-
-ChannelTrace::TraceEvent::~TraceEvent() { CSliceUnref(data_); }
-
-RefCountedPtr<BaseNode> ChannelTrace::TraceEvent::referenced_entity() const {
-  return referenced_entity_;
-}
-
 //
 // 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
+Json ChannelTrace::RenderJson() const {
+  if (max_memory_ == 0) return Json();
+  Json::Array array;
+  MutexLock lock(&mu_);
+  ForEachTraceEventLocked([&array](gpr_timespec timestamp, std::string line) {
+    Json::Object object = {
+        {"severity", Json::FromString("CT_INFO")},
+        {"timestamp", Json::FromString(gpr_format_timespec(timestamp))},
+        {"description", Json::FromString(std::move(line))},
+    };
+    array.push_back(Json::FromObject(std::move(object)));
+  });
+  Json::Object object;
+  object["creationTimestamp"] = Json::FromString(creation_timestamp());
+  if (num_events_logged_ > 0) {
+    object["numEventsLogged"] =
+        Json::FromString(absl::StrCat(num_events_logged_));
   }
-  TraceEvent* it = head_trace_;
-  while (it != nullptr) {
-    TraceEvent* to_free = it;
-    it = it->next();
-    delete to_free;
+  if (!array.empty()) {
+    object["events"] = Json::FromArray(std::move(array));
   }
+  return Json::FromObject(std::move(object));
 }
 
-void ChannelTrace::AddTraceEventHelper(TraceEvent* new_trace_event) {
+std::string ChannelTrace::creation_timestamp() const {
+  return gpr_format_timespec(time_created_.as_timespec(GPR_CLOCK_REALTIME));
+}
+
+ChannelTrace::EntryRef ChannelTrace::AppendEntry(
+    EntryRef parent, std::unique_ptr<Renderer> renderer) {
+  if (max_memory_ == 0) return EntryRef::Sentinel();
   MutexLock lock(&mu_);
   ++num_events_logged_;
-  // first event case
-  if (head_trace_ == nullptr) {
-    head_trace_ = tail_trace_ = new_trace_event;
-  } else {
-    // regular event add case
-    tail_trace_->set_next(new_trace_event);
-    tail_trace_ = tail_trace_->next();
-  }
-  event_list_memory_usage_ += new_trace_event->memory_usage();
-  // maybe garbage collect the tail until we are under the memory limit.
-  while (event_list_memory_usage_ > max_event_memory_) {
-    TraceEvent* to_free = head_trace_;
-    event_list_memory_usage_ -= to_free->memory_usage();
-    head_trace_ = head_trace_->next();
-    delete to_free;
+  const auto ref = NewEntry(parent, std::move(renderer));
+  while (current_memory_ > max_memory_ && first_entry_ != kSentinelId) {
+    DropEntryId(first_entry_);
+  }
+  if (GPR_UNLIKELY(current_memory_ > max_memory_)) {
+    entries_.shrink_to_fit();
+    current_memory_ = MemoryUsageOf(entries_);
   }
+  return ref;
 }
 
-void ChannelTrace::AddTraceEvent(Severity severity, const grpc_slice& data) {
-  if (max_event_memory_ == 0) {
-    CSliceUnref(data);
-    return;  // tracing is disabled if max_event_memory_ == 0
+ChannelTrace::EntryRef ChannelTrace::NewEntry(
+    EntryRef parent, std::unique_ptr<Renderer> renderer) {
+  if (parent.id != kSentinelId) {
+    if (parent.id >= entries_.size()) return EntryRef::Sentinel();
+    if (parent.salt != entries_[parent.id].salt) {
+      // Parent no longer present: no point adding child
+      return EntryRef::Sentinel();
+    }
+  }
+  uint16_t id;
+  if (next_free_entry_ != kSentinelId) {
+    id = next_free_entry_;
+    next_free_entry_ = entries_[id].next_chronologically;
+  } else {
+    id = entries_.size();
+    DCHECK_NE(id, kSentinelId);
+    entries_.emplace_back();
+    current_memory_ = MemoryUsageOf(entries_);
+  }
+  Entry& e = entries_[id];
+  e.when = Timestamp::Now();
+  e.parent = parent.id;
+  e.first_child = kSentinelId;
+  e.last_child = kSentinelId;
+  e.prev_sibling = kSentinelId;
+  e.next_sibling = kSentinelId;
+  e.next_chronologically = kSentinelId;
+  e.renderer = std::move(renderer);
+  e.prev_chronologically = last_entry_;
+  if (last_entry_ == kSentinelId) {
+    DCHECK_EQ(first_entry_, kSentinelId);
+    first_entry_ = id;
+  } else {
+    Entry& last = entries_[last_entry_];
+    DCHECK_EQ(last.next_chronologically, kSentinelId);
+    last.next_chronologically = id;
+  }
+  last_entry_ = id;
+  if (parent.id != kSentinelId) {
+    Entry& p = entries_[parent.id];
+    e.prev_sibling = p.last_child;
+    if (p.last_child == kSentinelId) {
+      DCHECK_EQ(p.first_child, kSentinelId);
+      p.first_child = id;
+    } else {
+      Entry& last = entries_[p.last_child];
+      DCHECK_EQ(last.next_sibling, kSentinelId);
+      last.next_sibling = id;
+    }
+    p.last_child = id;
   }
-  AddTraceEventHelper(new TraceEvent(severity, data));
+  current_memory_ += e.renderer->MemoryUsage();
+  DCHECK_EQ(MemoryUsageOf(entries_), current_memory_);
+  return EntryRef{id, e.salt};
 }
 
-void ChannelTrace::AddTraceEventWithReference(
-    Severity severity, const grpc_slice& data,
-    RefCountedPtr<BaseNode> referenced_entity) {
-  if (max_event_memory_ == 0) {
-    CSliceUnref(data);
-    return;  // tracing is disabled if max_event_memory_ == 0
+void ChannelTrace::DropEntry(EntryRef entry) {
+  if (entry.id == kSentinelId) return;
+  MutexLock lock(&mu_);
+  if (entry.id >= entries_.size()) return;
+  Entry& e = entries_[entry.id];
+  if (e.salt != entry.salt) return;
+  DropEntryId(entry.id);
+}
+
+void ChannelTrace::DropEntryId(uint16_t id) {
+  Entry& e = entries_[id];
+  while (e.first_child != kSentinelId) {
+    DropEntryId(e.first_child);
+  }
+  if (e.prev_chronologically != kSentinelId) {
+    Entry& prev = entries_[e.prev_chronologically];
+    DCHECK_EQ(prev.next_chronologically, id);
+    prev.next_chronologically = e.next_chronologically;
+  }
+  if (e.next_chronologically != kSentinelId) {
+    Entry& next = entries_[e.next_chronologically];
+    DCHECK_EQ(next.prev_chronologically, id);
+    next.prev_chronologically = e.prev_chronologically;
+  }
+  if (e.prev_sibling != kSentinelId) {
+    Entry& prev = entries_[e.prev_sibling];
+    DCHECK_EQ(prev.next_sibling, id);
+    prev.next_sibling = e.next_sibling;
+  }
+  if (e.next_sibling != kSentinelId) {
+    Entry& next = entries_[e.next_sibling];
+    DCHECK_EQ(next.prev_sibling, id);
+    next.prev_sibling = e.prev_sibling;
+  }
+  if (e.parent != kSentinelId) {
+    Entry& p = entries_[e.parent];
+    if (p.first_child == id) {
+      p.first_child = e.next_sibling;
+    }
+    if (p.last_child == id) {
+      p.last_child = e.prev_sibling;
+    }
   }
-  // create and fill up the new event
-  AddTraceEventHelper(
-      new TraceEvent(severity, data, std::move(referenced_entity)));
+  if (first_entry_ == id) {
+    first_entry_ = e.next_chronologically;
+  }
+  if (last_entry_ == id) {
+    last_entry_ = e.prev_chronologically;
+  }
+  ++e.salt;
+  e.next_chronologically = next_free_entry_;
+  current_memory_ -= e.renderer->MemoryUsage();
+  e.renderer.reset();
+  DCHECK_EQ(current_memory_, MemoryUsageOf(entries_));
+  next_free_entry_ = id;
 }
 
-std::string ChannelTrace::TraceEvent::description() const {
-  char* description = grpc_slice_to_c_string(data_);
-  std::string s(description);
-  gpr_free(description);
-  return s;
+void ChannelTrace::ForEachTraceEvent(
+    absl::FunctionRef<void(gpr_timespec, std::string)> callback) const {
+  MutexLock lock(&mu_);
+  ForEachTraceEventLocked(callback);
 }
 
 void ChannelTrace::ForEachTraceEventLocked(
-    absl::FunctionRef<void(gpr_timespec, Severity, std::string,
-                           RefCountedPtr<BaseNode>)>
-        callback) const {
-  TraceEvent* it = head_trace_;
-  while (it != nullptr) {
-    callback(it->timestamp(), it->severity(), it->description(),
-             it->referenced_entity());
-    it = it->next();
+    absl::FunctionRef<void(gpr_timespec, std::string)> callback) const {
+  uint16_t id = first_entry_;
+  while (id != kSentinelId) {
+    const Entry& e = entries_[id];
+    if (e.parent == kSentinelId) RenderEntry(e, callback, 0);
+    id = e.next_chronologically;
   }
 }
 
-Json ChannelTrace::RenderJson() const {
-  // Tracing is disabled if max_event_memory_ == 0.
-  if (max_event_memory_ == 0) {
-    return Json();  // JSON null
-  }
-  Json::Object object = {
-      {"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_));
+void ChannelTrace::RenderEntry(
+    const Entry& entry,
+    absl::FunctionRef<void(gpr_timespec, std::string)> callback,
+    int depth) const {
+  if (entry.renderer != nullptr) {
+    callback(entry.when.as_timespec(GPR_CLOCK_REALTIME),
+             entry.renderer->Render());
+  } else if (entry.first_child != kSentinelId) {
+    callback(entry.when.as_timespec(GPR_CLOCK_REALTIME),
+             "?unknown parent entry?");
   }
-  // Only add in the event list if it is non-empty.
-  Json::Array array;
-  ForEachTraceEventLocked([&array](gpr_timespec timestamp, Severity severity,
-                                   std::string description,
-                                   RefCountedPtr<BaseNode> referenced_entity) {
-    Json::Object object = {
-        {"description", Json::FromString(description)},
-        {"severity", Json::FromString(SeverityString(severity))},
-        {"timestamp", Json::FromString(gpr_format_timespec(timestamp))},
-    };
-    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()))},
-      });
+  if (entry.first_child != kSentinelId) {
+    uint16_t id = entry.first_child;
+    while (id != kSentinelId) {
+      const Entry& e = entries_[id];
+      RenderEntry(e, callback, depth + 1);
+      id = e.next_sibling;
     }
-    array.emplace_back(Json::FromObject(std::move(object)));
-  });
-  if (!array.empty()) {
-    object["events"] = Json::FromArray(std::move(array));
   }
-  return Json::FromObject(std::move(object));
 }
 
-std::string ChannelTrace::creation_timestamp() const {
-  return gpr_format_timespec(time_created_);
+void ChannelTrace::Render(grpc_channelz_v2_Entity* entity,
+                          upb_Arena* arena) const {
+  MutexLock lock(&mu_);
+  uint16_t id = first_entry_;
+  while (id != kSentinelId) {
+    const Entry& e = entries_[id];
+    if (e.parent == kSentinelId) {
+      RenderEntry(e, grpc_channelz_v2_Entity_add_trace(entity, arena), arena);
+    }
+    id = e.next_chronologically;
+  }
+}
+
+void ChannelTrace::RenderEntry(const Entry& entry,
+                               grpc_channelz_v2_TraceEvent* trace_event,
+                               upb_Arena* arena) const {
+  TimestampToUpb(
+      entry.when.as_timespec(GPR_CLOCK_REALTIME),
+      grpc_channelz_v2_TraceEvent_mutable_timestamp(trace_event, arena));
+  if (entry.renderer != nullptr) {
+    grpc_channelz_v2_TraceEvent_set_description(
+        trace_event, CopyStdStringToUpbString(entry.renderer->Render(), arena));
+  }
+  for (uint16_t id = entry.first_child; id != kSentinelId;
+       id = entries_[id].next_sibling) {
+    auto* child = grpc_channelz_v2_TraceEvent_new(arena);
+    RenderEntry(entries_[id], child, arena);
+    size_t length;
+    auto* bytes = grpc_channelz_v2_TraceEvent_serialize(child, arena, &length);
+    auto* data = grpc_channelz_v2_Data_new(arena);
+    grpc_channelz_v2_Data_set_name(data, StdStringToUpbString("child_trace"));
+    auto* any = grpc_channelz_v2_Data_mutable_value(data, arena);
+    google_protobuf_Any_set_value(
+        any, upb_StringView_FromDataAndSize(bytes, length));
+    google_protobuf_Any_set_type_url(
+        any, StdStringToUpbString(
+                 "type.googleapis.com/grpc.channelz.v2.TraceEvent"));
+  }
 }
 
+size_t testing::GetSizeofTraceEvent() { return sizeof(ChannelTrace::Entry); }
+
 }  // namespace channelz
 }  // namespace grpc_core