grpc 1.57.0 → 1.58.0.pre1

data/src/core/lib/avl/avl.h

@@ -20,10 +20,11 @@
 #include <stdlib.h>
 
 #include <algorithm>  // IWYU pragma: keep
-#include <memory>
 #include <utility>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -42,12 +43,12 @@ class AVL {
   template <typename SomethingLikeK>
   const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
-    return n ? &n->kv.second : nullptr;
+    return n != nullptr ? &n->kv.second : nullptr;
   }
 
   const std::pair<K, V>* LookupBelow(const K& key) const {
     NodePtr n = GetBelow(root_, *key);
-    return n ? &n->kv : nullptr;
+    return n != nullptr ? &n->kv : nullptr;
   }
 
   bool Empty() const { return root_ == nullptr; }
@@ -95,8 +96,8 @@ class AVL {
  private:
   struct Node;
 
-  typedef std::shared_ptr<Node> NodePtr;
-  struct Node : public std::enable_shared_from_this<Node> {
+  typedef RefCountedPtr<Node> NodePtr;
+  struct Node : public RefCounted<Node, NonPolymorphicRefCount> {
     Node(K k, V v, NodePtr l, NodePtr r, long h)
         : kv(std::move(k), std::move(v)),
           left(std::move(l)),
@@ -167,12 +168,12 @@ class AVL {
     ForEachImpl(n->right.get(), std::forward<F>(f));
   }
 
-  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+  static long Height(const NodePtr& n) { return n != nullptr ? n->height : 0; }
 
   static NodePtr MakeNode(K key, V value, const NodePtr& left,
                           const NodePtr& right) {
-    return std::make_shared<Node>(std::move(key), std::move(value), left, right,
-                                  1 + std::max(Height(left), Height(right)));
+    return MakeRefCounted<Node>(std::move(key), std::move(value), left, right,
+                                1 + std::max(Height(left), Height(right)));
   }
 
   template <typename SomethingLikeK>
@@ -259,7 +260,7 @@ class AVL {
   }
 
   static NodePtr AddKey(const NodePtr& node, K key, V value) {
-    if (!node) {
+    if (node == nullptr) {
       return MakeNode(std::move(key), std::move(value), nullptr, nullptr);
     }
     if (node->kv.first < key) {
@@ -318,170 +319,6 @@ class AVL {
   }
 };
 
-template <class K>
-class AVL<K, void> {
- public:
-  AVL() {}
-
-  AVL Add(K key) const { return AVL(AddKey(root_, std::move(key))); }
-  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
-  bool Lookup(const K& key) const { return Get(root_, key) != nullptr; }
-  bool Empty() const { return root_ == nullptr; }
-
-  template <class F>
-  void ForEach(F&& f) const {
-    ForEachImpl(root_.get(), std::forward<F>(f));
-  }
-
-  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
-
- private:
-  struct Node;
-
-  typedef std::shared_ptr<Node> NodePtr;
-  struct Node : public std::enable_shared_from_this<Node> {
-    Node(K k, NodePtr l, NodePtr r, long h)
-        : key(std::move(k)),
-          left(std::move(l)),
-          right(std::move(r)),
-          height(h) {}
-    const K key;
-    const NodePtr left;
-    const NodePtr right;
-    const long height;
-  };
-  NodePtr root_;
-
-  explicit AVL(NodePtr root) : root_(std::move(root)) {}
-
-  template <class F>
-  static void ForEachImpl(const Node* n, F&& f) {
-    if (n == nullptr) return;
-    ForEachImpl(n->left.get(), std::forward<F>(f));
-    f(const_cast<const K&>(n->key));
-    ForEachImpl(n->right.get(), std::forward<F>(f));
-  }
-
-  static long Height(const NodePtr& n) { return n ? n->height : 0; }
-
-  static NodePtr MakeNode(K key, const NodePtr& left, const NodePtr& right) {
-    return std::make_shared<Node>(std::move(key), left, right,
-                                  1 + std::max(Height(left), Height(right)));
-  }
-
-  static NodePtr Get(const NodePtr& node, const K& key) {
-    if (node == nullptr) {
-      return nullptr;
-    }
-
-    if (node->key > key) {
-      return Get(node->left, key);
-    } else if (node->key < key) {
-      return Get(node->right, key);
-    } else {
-      return node;
-    }
-  }
-
-  static NodePtr RotateLeft(K key, const NodePtr& left, const NodePtr& right) {
-    return MakeNode(right->key, MakeNode(std::move(key), left, right->left),
-                    right->right);
-  }
-
-  static NodePtr RotateRight(K key, const NodePtr& left, const NodePtr& right) {
-    return MakeNode(left->key, left->left,
-                    MakeNode(std::move(key), left->right, right));
-  }
-
-  static NodePtr RotateLeftRight(K key, const NodePtr& left,
-                                 const NodePtr& right) {
-    // rotate_right(..., rotate_left(left), right)
-    return MakeNode(left->right->key,
-                    MakeNode(left->key, left->left, left->right->left),
-                    MakeNode(std::move(key), left->right->right, right));
-  }
-
-  static NodePtr RotateRightLeft(K key, const NodePtr& left,
-                                 const NodePtr& right) {
-    // rotate_left(..., left, rotate_right(right))
-    return MakeNode(right->left->key,
-                    MakeNode(std::move(key), left, right->left->left),
-                    MakeNode(right->key, right->left->right, right->right));
-  }
-
-  static NodePtr Rebalance(K key, const NodePtr& left, const NodePtr& right) {
-    switch (Height(left) - Height(right)) {
-      case 2:
-        if (Height(left->left) - Height(left->right) == -1) {
-          return RotateLeftRight(std::move(key), left, right);
-        } else {
-          return RotateRight(std::move(key), left, right);
-        }
-      case -2:
-        if (Height(right->left) - Height(right->right) == 1) {
-          return RotateRightLeft(std::move(key), left, right);
-        } else {
-          return RotateLeft(std::move(key), left, right);
-        }
-      default:
-        return MakeNode(key, left, right);
-    }
-  }
-
-  static NodePtr AddKey(const NodePtr& node, K key) {
-    if (!node) {
-      return MakeNode(std::move(key), nullptr, nullptr);
-    }
-    if (node->key < key) {
-      return Rebalance(node->key, node->left,
-                       AddKey(node->right, std::move(key)));
-    }
-    if (key < node->key) {
-      return Rebalance(node->key, AddKey(node->left, std::move(key)),
-                       node->right);
-    }
-    return MakeNode(std::move(key), node->left, node->right);
-  }
-
-  static NodePtr InOrderHead(NodePtr node) {
-    while (node->left != nullptr) {
-      node = node->left;
-    }
-    return node;
-  }
-
-  static NodePtr InOrderTail(NodePtr node) {
-    while (node->right != nullptr) {
-      node = node->right;
-    }
-    return node;
-  }
-
-  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
-    if (node == nullptr) {
-      return nullptr;
-    }
-    if (key < node->key) {
-      return Rebalance(node->key, RemoveKey(node->left, key), node->right);
-    } else if (node->key < key) {
-      return Rebalance(node->key, node->left, RemoveKey(node->right, key));
-    } else {
-      if (node->left == nullptr) {
-        return node->right;
-      } else if (node->right == nullptr) {
-        return node->left;
-      } else if (node->left->height < node->right->height) {
-        NodePtr h = InOrderHead(node->right);
-        return Rebalance(h->key, node->left, RemoveKey(node->right, h->key));
-      } else {
-        NodePtr h = InOrderTail(node->left);
-        return Rebalance(h->key, RemoveKey(node->left, h->key), node->right);
-      }
-    }
-    abort();
-  }
-};
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_AVL_AVL_H

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

@@ -20,6 +20,14 @@
 
 #include "src/core/lib/channel/call_tracer.h"
 
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/context.h"
+
 namespace grpc_core {
 
 //
@@ -27,6 +35,7 @@ namespace grpc_core {
 //
 
 namespace {
+
 ServerCallTracerFactory* g_server_call_tracer_factory_ = nullptr;
 
 const char* kServerCallTracerFactoryChannelArgName =
@@ -48,4 +57,284 @@ absl::string_view ServerCallTracerFactory::ChannelArgName() {
   return kServerCallTracerFactoryChannelArgName;
 }
 
+class DelegatingClientCallTracer : public ClientCallTracer {
+ public:
+  class DelegatingClientCallAttemptTracer
+      : public ClientCallTracer::CallAttemptTracer {
+   public:
+    explicit DelegatingClientCallAttemptTracer(
+        std::vector<CallAttemptTracer*> tracers)
+        : tracers_(std::move(tracers)) {
+      GPR_DEBUG_ASSERT(!tracers_.empty());
+    }
+    ~DelegatingClientCallAttemptTracer() override {}
+    void RecordSendInitialMetadata(
+        grpc_metadata_batch* send_initial_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendInitialMetadata(send_initial_metadata);
+      }
+    }
+    void RecordSendTrailingMetadata(
+        grpc_metadata_batch* send_trailing_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendTrailingMetadata(send_trailing_metadata);
+      }
+    }
+    void RecordSendMessage(const SliceBuffer& send_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendMessage(send_message);
+      }
+    }
+    void RecordSendCompressedMessage(
+        const SliceBuffer& send_compressed_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendCompressedMessage(send_compressed_message);
+      }
+    }
+    void RecordReceivedInitialMetadata(
+        grpc_metadata_batch* recv_initial_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
+      }
+    }
+    void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedMessage(recv_message);
+      }
+    }
+    void RecordReceivedDecompressedMessage(
+        const SliceBuffer& recv_decompressed_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
+      }
+    }
+    void RecordCancel(grpc_error_handle cancel_error) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordCancel(cancel_error);
+      }
+    }
+    void RecordReceivedTrailingMetadata(
+        absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
+        const grpc_transport_stream_stats* transport_stream_stats) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedTrailingMetadata(status, recv_trailing_metadata,
+                                               transport_stream_stats);
+      }
+    }
+    void RecordEnd(const gpr_timespec& latency) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordEnd(latency);
+      }
+    }
+    void RecordAnnotation(absl::string_view annotation) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordAnnotation(annotation);
+      }
+    }
+    void RecordAnnotation(const Annotation& annotation) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordAnnotation(annotation);
+      }
+    }
+    std::string TraceId() override { return tracers_[0]->TraceId(); }
+    std::string SpanId() override { return tracers_[0]->SpanId(); }
+    bool IsSampled() override { return tracers_[0]->IsSampled(); }
+    bool IsDelegatingTracer() override { return true; }
+
+   private:
+    // There is no additional synchronization needed since filters/interceptors
+    // will be adding call tracers to the context and these are already
+    // synchronized through promises/call combiners (single promise running per
+    // call at any moment).
+    std::vector<CallAttemptTracer*> tracers_;
+  };
+  explicit DelegatingClientCallTracer(ClientCallTracer* tracer)
+      : tracers_{tracer} {}
+  ~DelegatingClientCallTracer() override {}
+  CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) override {
+    std::vector<CallAttemptTracer*> attempt_tracers;
+    attempt_tracers.reserve(tracers_.size());
+    for (auto* tracer : tracers_) {
+      auto* attempt_tracer = tracer->StartNewAttempt(is_transparent_retry);
+      GPR_DEBUG_ASSERT(attempt_tracer != nullptr);
+      attempt_tracers.push_back(attempt_tracer);
+    }
+    return GetContext<Arena>()->ManagedNew<DelegatingClientCallAttemptTracer>(
+        std::move(attempt_tracers));
+  }
+
+  void RecordAnnotation(absl::string_view annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  void RecordAnnotation(const Annotation& annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  std::string TraceId() override { return tracers_[0]->TraceId(); }
+  std::string SpanId() override { return tracers_[0]->SpanId(); }
+  bool IsSampled() override { return tracers_[0]->IsSampled(); }
+  bool IsDelegatingTracer() override { return true; }
+
+  // There is no additional synchronization needed since filters/interceptors
+  // will be adding call tracers to the context and these are already
+  // synchronized through promises/call combiners (single promise running per
+  // call at any moment).
+  void AddTracer(ClientCallTracer* tracer) { tracers_.push_back(tracer); }
+
+ private:
+  std::vector<ClientCallTracer*> tracers_;
+};
+
+class DelegatingServerCallTracer : public ServerCallTracer {
+ public:
+  explicit DelegatingServerCallTracer(ServerCallTracer* tracer)
+      : tracers_{tracer} {}
+  ~DelegatingServerCallTracer() override {}
+  void RecordSendInitialMetadata(
+      grpc_metadata_batch* send_initial_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendInitialMetadata(send_initial_metadata);
+    }
+  }
+  void RecordSendTrailingMetadata(
+      grpc_metadata_batch* send_trailing_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendTrailingMetadata(send_trailing_metadata);
+    }
+  }
+  void RecordSendMessage(const SliceBuffer& send_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendMessage(send_message);
+    }
+  }
+  void RecordSendCompressedMessage(
+      const SliceBuffer& send_compressed_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendCompressedMessage(send_compressed_message);
+    }
+  }
+  void RecordReceivedInitialMetadata(
+      grpc_metadata_batch* recv_initial_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
+    }
+  }
+  void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedMessage(recv_message);
+    }
+  }
+  void RecordReceivedDecompressedMessage(
+      const SliceBuffer& recv_decompressed_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
+    }
+  }
+  void RecordCancel(grpc_error_handle cancel_error) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordCancel(cancel_error);
+    }
+  }
+  void RecordReceivedTrailingMetadata(
+      grpc_metadata_batch* recv_trailing_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedTrailingMetadata(recv_trailing_metadata);
+    }
+  }
+  void RecordEnd(const grpc_call_final_info* final_info) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordEnd(final_info);
+    }
+  }
+  void RecordAnnotation(absl::string_view annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  void RecordAnnotation(const Annotation& annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  std::string TraceId() override { return tracers_[0]->TraceId(); }
+  std::string SpanId() override { return tracers_[0]->SpanId(); }
+  bool IsSampled() override { return tracers_[0]->IsSampled(); }
+  bool IsDelegatingTracer() override { return true; }
+
+  void AddTracer(ServerCallTracer* tracer) { tracers_.push_back(tracer); }
+
+ private:
+  // The ServerCallTracerFilter will be responsible for making sure that the
+  // tracers are added in a thread-safe manner. It is imagined that the filter
+  // will just invoke the factories in the server call tracer factory list
+  // sequentially, removing the need for any synchronization.
+  std::vector<ServerCallTracer*> tracers_;
+};
+
+void AddClientCallTracerToContext(grpc_call_context_element* call_context,
+                                  ClientCallTracer* tracer) {
+  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
+      nullptr) {
+    // This is the first call tracer. Set it directly.
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
+        nullptr;
+  } else {
+    // There was already a call tracer present.
+    auto* orig_tracer = static_cast<ClientCallTracer*>(
+        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    if (orig_tracer->IsDelegatingTracer()) {
+      // We already created a delegating tracer. Just add the new tracer to the
+      // list.
+      static_cast<DelegatingClientCallTracer*>(orig_tracer)->AddTracer(tracer);
+    } else {
+      // Create a new delegating tracer and add the first tracer and the new
+      // tracer to the list.
+      auto* delegating_tracer =
+          GetContext<Arena>()->ManagedNew<DelegatingClientCallTracer>(
+              orig_tracer);
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
+          delegating_tracer;
+      delegating_tracer->AddTracer(tracer);
+    }
+  }
+}
+
+void AddServerCallTracerToContext(grpc_call_context_element* call_context,
+                                  ServerCallTracer* tracer) {
+  GPR_DEBUG_ASSERT(
+      call_context[GRPC_CONTEXT_CALL_TRACER].value ==
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
+      nullptr) {
+    // This is the first call tracer. Set it directly.
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
+        nullptr;
+  } else {
+    // There was already a call tracer present.
+    auto* orig_tracer = static_cast<ServerCallTracer*>(
+        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    if (orig_tracer->IsDelegatingTracer()) {
+      // We already created a delegating tracer. Just add the new tracer to the
+      // list.
+      static_cast<DelegatingServerCallTracer*>(orig_tracer)->AddTracer(tracer);
+    } else {
+      // Create a new delegating tracer and add the first tracer and the new
+      // tracer to the list.
+      auto* delegating_tracer =
+          GetContext<Arena>()->ManagedNew<DelegatingServerCallTracer>(
+              orig_tracer);
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
+          delegating_tracer;
+      call_context[GRPC_CONTEXT_CALL_TRACER].value = delegating_tracer;
+      delegating_tracer->AddTracer(tracer);
+    }
+  }
+}
+
 }  // namespace grpc_core

data/src/core/lib/channel/call_tracer.h

@@ -30,6 +30,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -49,14 +50,37 @@ namespace grpc_core {
 // The base class for all tracer implementations.
 class CallTracerAnnotationInterface {
  public:
+  // Enum associated with types of Annotations.
+  enum class AnnotationType {
+    kMetadataSizes,
+    kDoNotUse_MustBeLast,
+  };
+
+  // Base class to define a new type of annotation.
+  class Annotation {
+   public:
+    explicit Annotation(AnnotationType type) : type_(type) {}
+    AnnotationType type() const { return type_; }
+    virtual std::string ToString() const = 0;
+    virtual ~Annotation() = default;
+
+   private:
+    const AnnotationType type_;
+  };
+
   virtual ~CallTracerAnnotationInterface() {}
   // Records an annotation on the call attempt.
   // TODO(yashykt): If needed, extend this to attach attributes with
   // annotations.
   virtual void RecordAnnotation(absl::string_view annotation) = 0;
+  virtual void RecordAnnotation(const Annotation& annotation) = 0;
   virtual std::string TraceId() = 0;
   virtual std::string SpanId() = 0;
   virtual bool IsSampled() = 0;
+  // Indicates whether this tracer is a delegating tracer or not.
+  // `DelegatingClientCallTracer`, `DelegatingClientCallAttemptTracer` and
+  // `DelegatingServerCallTracer` are the only delegating call tracers.
+  virtual bool IsDelegatingTracer() { return false; }
 };
 
 // The base class for CallAttemptTracer and ServerCallTracer.
@@ -161,6 +185,17 @@ class ServerCallTracerFactory {
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
 
+// Convenience functions to add call tracers to a call context. Allows setting
+// multiple call tracers to a single call. It is only valid to add client call
+// tracers before the client_channel filter sees the send_initial_metadata op.
+void AddClientCallTracerToContext(grpc_call_context_element* call_context,
+                                  ClientCallTracer* tracer);
+
+// TODO(yashykt): We want server call tracers to be registered through the
+// ServerCallTracerFactory, which has yet to be made into a list.
+void AddServerCallTracerToContext(grpc_call_context_element* call_context,
+                                  ServerCallTracer* tracer);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_CHANNEL_CALL_TRACER_H