grpc 1.66.0 → 1.67.0.pre1

data/src/core/lib/transport/call_arena_allocator.cc

@@ -20,22 +20,8 @@
 
 namespace grpc_core {
 
-void CallSizeEstimator::UpdateCallSizeEstimate(size_t size) {
-  size_t cur = call_size_estimate_.load(std::memory_order_relaxed);
-  if (cur < size) {
-    // size grew: update estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, size, std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  } else if (cur == size) {
-    // no change: holding pattern
-  } else if (cur > 0) {
-    // size shrank: decrease estimate
-    call_size_estimate_.compare_exchange_weak(
-        cur, std::min(cur - 1, (255 * cur + size) / 256),
-        std::memory_order_relaxed, std::memory_order_relaxed);
-    // if we lose: never mind, something else will likely update soon enough
-  }
+void CallArenaAllocator::FinalizeArena(Arena* arena) {
+  call_size_estimator_.UpdateCallSizeEstimate(arena->TotalUsedBytes());
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/call_arena_allocator.h

@@ -33,7 +33,7 @@ class CallSizeEstimator final {
   explicit CallSizeEstimator(size_t initial_estimate)
       : call_size_estimate_(initial_estimate) {}
 
-  size_t CallSizeEstimate() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION size_t CallSizeEstimate() {
     // We round up our current estimate to the NEXT value of kRoundUpSize.
     // This ensures:
     //  1. a consistent size allocation when our estimate is drifting slowly
@@ -46,7 +46,24 @@ class CallSizeEstimator final {
            ~(kRoundUpSize - 1);
   }
 
-  void UpdateCallSizeEstimate(size_t size);
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void UpdateCallSizeEstimate(
+      size_t size) {
+    size_t cur = call_size_estimate_.load(std::memory_order_relaxed);
+    if (cur < size) {
+      // size grew: update estimate
+      call_size_estimate_.compare_exchange_weak(
+          cur, size, std::memory_order_relaxed, std::memory_order_relaxed);
+      // if we lose: never mind, something else will likely update soon enough
+    } else if (cur == size) {
+      // no change: holding pattern
+    } else if (cur > 0) {
+      // size shrank: decrease estimate
+      call_size_estimate_.compare_exchange_weak(
+          cur, std::min(cur - 1, (255 * cur + size) / 256),
+          std::memory_order_relaxed, std::memory_order_relaxed);
+      // if we lose: never mind, something else will likely update soon enough
+    }
+  }
 
  private:
   std::atomic<size_t> call_size_estimate_;
@@ -62,9 +79,7 @@ class CallArenaAllocator final : public ArenaFactory {
     return Arena::Create(call_size_estimator_.CallSizeEstimate(), Ref());
   }
 
-  void FinalizeArena(Arena* arena) override {
-    call_size_estimator_.UpdateCallSizeEstimate(arena->TotalUsedBytes());
-  }
+  void FinalizeArena(Arena* arena) override;
 
   size_t CallSizeEstimate() { return call_size_estimator_.CallSizeEstimate(); }
 

data/src/core/lib/transport/call_filters.cc

@@ -188,10 +188,9 @@ void CallFilters::Finalize(const grpc_call_final_info* final_info) {
 void CallFilters::CancelDueToFailedPipeOperation(SourceLocation but_where) {
   // We expect something cancelled before now
   if (push_server_trailing_metadata_ == nullptr) return;
-  if (GRPC_TRACE_FLAG_ENABLED(promise_primitives)) {
-    VLOG(2).AtLocation(but_where.file(), but_where.line())
-        << "Cancelling due to failed pipe operation: " << DebugString();
-  }
+  GRPC_TRACE_VLOG(promise_primitives, 2)
+          .AtLocation(but_where.file(), but_where.line())
+      << "Cancelling due to failed pipe operation: " << DebugString();
   auto status =
       ServerMetadataFromStatus(GRPC_STATUS_CANCELLED, "Failed pipe operation");
   status->Set(GrpcCallWasCancelled(), true);
@@ -200,11 +199,9 @@ void CallFilters::CancelDueToFailedPipeOperation(SourceLocation but_where) {
 
 void CallFilters::PushServerTrailingMetadata(ServerMetadataHandle md) {
   CHECK(md != nullptr);
-  if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    LOG(INFO) << GetContext<Activity>()->DebugTag()
-              << " PushServerTrailingMetadata[" << this
-              << "]: " << md->DebugString() << " into " << DebugString();
-  }
+  GRPC_TRACE_LOG(call, INFO)
+      << GetContext<Activity>()->DebugTag() << " PushServerTrailingMetadata["
+      << this << "]: " << md->DebugString() << " into " << DebugString();
   CHECK(md != nullptr);
   if (call_state_.PushServerTrailingMetadata(
           md->get(GrpcCallWasCancelled()).value_or(false))) {

data/src/core/lib/transport/call_spine.h

@@ -17,7 +17,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/dual_ref_counted.h"
@@ -51,23 +50,24 @@ class CallSpine final : public Party {
         std::move(client_initial_metadata), std::move(arena)));
   }
 
-  ~CallSpine() override {}
+  ~CallSpine() override { CallOnDone(true); }
 
   CallFilters& call_filters() { return call_filters_; }
 
   // Add a callback to be called when server trailing metadata is received.
-  void OnDone(absl::AnyInvocable<void()> fn) {
+  void OnDone(absl::AnyInvocable<void(bool)> fn) {
     if (on_done_ == nullptr) {
       on_done_ = std::move(fn);
       return;
     }
-    on_done_ = [first = std::move(fn), next = std::move(on_done_)]() mutable {
-      first();
-      next();
+    on_done_ = [first = std::move(fn),
+                next = std::move(on_done_)](bool cancelled) mutable {
+      first(cancelled);
+      next(cancelled);
     };
   }
-  void CallOnDone() {
-    if (on_done_ != nullptr) std::exchange(on_done_, nullptr)();
+  void CallOnDone(bool cancelled) {
+    if (on_done_ != nullptr) std::exchange(on_done_, nullptr)(cancelled);
   }
 
   auto PullServerInitialMetadata() {
@@ -75,7 +75,12 @@ class CallSpine final : public Party {
   }
 
   auto PullServerTrailingMetadata() {
-    return call_filters().PullServerTrailingMetadata();
+    return Map(
+        call_filters().PullServerTrailingMetadata(),
+        [this](ServerMetadataHandle result) {
+          CallOnDone(result->get(GrpcCallWasCancelled()).value_or(false));
+          return result;
+        });
   }
 
   auto PushClientToServerMessage(MessageHandle message) {
@@ -190,7 +195,7 @@ class CallSpine final : public Party {
 
   // Call filters/pipes part of the spine
   CallFilters call_filters_;
-  absl::AnyInvocable<void()> on_done_{nullptr};
+  absl::AnyInvocable<void(bool)> on_done_{nullptr};
 };
 
 class CallInitiator {
@@ -227,7 +232,9 @@ class CallInitiator {
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
-  void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
+  void OnDone(absl::AnyInvocable<void(bool)> fn) {
+    spine_->OnDone(std::move(fn));
+  }
 
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
@@ -274,7 +281,9 @@ class CallHandler {
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
-  void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
+  void OnDone(absl::AnyInvocable<void(bool)> fn) {
+    spine_->OnDone(std::move(fn));
+  }
 
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
@@ -327,7 +336,9 @@ class UnstartedCallHandler {
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
-  void OnDone(absl::AnyInvocable<void()> fn) { spine_->OnDone(std::move(fn)); }
+  void OnDone(absl::AnyInvocable<void(bool)> fn) {
+    spine_->OnDone(std::move(fn));
+  }
 
   template <typename Promise>
   auto CancelIfFails(Promise promise) {

data/src/core/lib/transport/connectivity_state.cc

@@ -72,12 +72,11 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
  private:
   static void SendNotification(void* arg, grpc_error_handle /*ignored*/) {
     Notifier* self = static_cast<Notifier*>(arg);
-    if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      LOG(INFO) << "watcher " << self->watcher_.get()
-                << ": delivering async notification for "
-                << ConnectivityStateName(self->state_) << " ("
-                << self->status_.ToString() << ")";
-    }
+    GRPC_TRACE_LOG(connectivity_state, INFO)
+        << "watcher " << self->watcher_.get()
+        << ": delivering async notification for "
+        << ConnectivityStateName(self->state_) << " ("
+        << self->status_.ToString() << ")";
     self->watcher_->OnConnectivityStateChange(self->state_, self->status_);
     delete self;
   }
@@ -104,12 +103,11 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
       state_.load(std::memory_order_relaxed);
   if (current_state == GRPC_CHANNEL_SHUTDOWN) return;
   for (const auto& p : watchers_) {
-    if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-                << "]: notifying watcher " << p.first << ": "
-                << ConnectivityStateName(current_state) << " -> "
-                << ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN);
-    }
+    GRPC_TRACE_LOG(connectivity_state, INFO)
+        << "ConnectivityStateTracker " << name_ << "[" << this
+        << "]: notifying watcher " << p.first << ": "
+        << ConnectivityStateName(current_state) << " -> "
+        << ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN);
     p.second->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
   }
 }
@@ -117,19 +115,17 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
 void ConnectivityStateTracker::AddWatcher(
     grpc_connectivity_state initial_state,
     OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
-  if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-              << "]: add watcher " << watcher.get();
-  }
+  GRPC_TRACE_LOG(connectivity_state, INFO)
+      << "ConnectivityStateTracker " << name_ << "[" << this
+      << "]: add watcher " << watcher.get();
   grpc_connectivity_state current_state =
       state_.load(std::memory_order_relaxed);
   if (initial_state != current_state) {
-    if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-                << "]: notifying watcher " << watcher.get() << ": "
-                << ConnectivityStateName(initial_state) << " -> "
-                << ConnectivityStateName(current_state);
-    }
+    GRPC_TRACE_LOG(connectivity_state, INFO)
+        << "ConnectivityStateTracker " << name_ << "[" << this
+        << "]: notifying watcher " << watcher.get() << ": "
+        << ConnectivityStateName(initial_state) << " -> "
+        << ConnectivityStateName(current_state);
     watcher->Notify(current_state, status_);
   }
   // If we're in state SHUTDOWN, don't add the watcher, so that it will
@@ -141,10 +137,9 @@ void ConnectivityStateTracker::AddWatcher(
 
 void ConnectivityStateTracker::RemoveWatcher(
     ConnectivityStateWatcherInterface* watcher) {
-  if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-              << "]: remove watcher " << watcher;
-  }
+  GRPC_TRACE_LOG(connectivity_state, INFO)
+      << "ConnectivityStateTracker " << name_ << "[" << this
+      << "]: remove watcher " << watcher;
   watchers_.erase(watcher);
 }
 
@@ -154,21 +149,19 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
   grpc_connectivity_state current_state =
       state_.load(std::memory_order_relaxed);
   if (state == current_state) return;
-  if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-              << "]: " << ConnectivityStateName(current_state) << " -> "
-              << ConnectivityStateName(state) << " (" << reason << ", "
-              << status.ToString() << ")";
-  }
+  GRPC_TRACE_LOG(connectivity_state, INFO)
+      << "ConnectivityStateTracker " << name_ << "[" << this
+      << "]: " << ConnectivityStateName(current_state) << " -> "
+      << ConnectivityStateName(state) << " (" << reason << ", "
+      << status.ToString() << ")";
   state_.store(state, std::memory_order_relaxed);
   status_ = status;
   for (const auto& p : watchers_) {
-    if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-                << "]: notifying watcher " << p.first << ": "
-                << ConnectivityStateName(current_state) << " -> "
-                << ConnectivityStateName(state);
-    }
+    GRPC_TRACE_LOG(connectivity_state, INFO)
+        << "ConnectivityStateTracker " << name_ << "[" << this
+        << "]: notifying watcher " << p.first << ": "
+        << ConnectivityStateName(current_state) << " -> "
+        << ConnectivityStateName(state);
     p.second->Notify(state, status);
   }
   // If the new state is SHUTDOWN, orphan all of the watchers.  This
@@ -178,10 +171,9 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
 
 grpc_connectivity_state ConnectivityStateTracker::state() const {
   grpc_connectivity_state state = state_.load(std::memory_order_relaxed);
-  if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
-              << "]: get current state: " << ConnectivityStateName(state);
-  }
+  GRPC_TRACE_LOG(connectivity_state, INFO)
+      << "ConnectivityStateTracker " << name_ << "[" << this
+      << "]: get current state: " << ConnectivityStateName(state);
   return state;
 }
 

data/src/core/lib/transport/metadata_batch.h

@@ -36,7 +36,6 @@
 
 #include <grpc/impl/compression_types.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/compression/compression_internal.h"
@@ -1052,6 +1051,26 @@ struct LogWrapper {
   }
 };
 
+// Callable for the table FilterIn -- for each value, call the
+// appropriate filter method to determine of the value should be kept or
+// removed.
+template <typename Filterer>
+struct FilterWrapper {
+  Filterer filter_fn;
+
+  template <typename Which,
+            absl::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
+  bool operator()(const Value<Which>& /*which*/) {
+    return filter_fn(Which());
+  }
+
+  template <typename Which,
+            absl::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
+  bool operator()(const Value<Which>& /*which*/) {
+    return true;
+  }
+};
+
 // Encoder to compute TransportSize
 class TransportSizeEncoder {
  public:
@@ -1094,6 +1113,16 @@ class UnknownMap {
   BackingType::const_iterator begin() const { return unknown_.cbegin(); }
   BackingType::const_iterator end() const { return unknown_.cend(); }
 
+  template <typename Filterer>
+  void Filter(Filterer* filter_fn) {
+    unknown_.erase(
+        std::remove_if(unknown_.begin(), unknown_.end(),
+                       [&](auto& pair) {
+                         return !(*filter_fn)(pair.first.as_string_view());
+                       }),
+        unknown_.end());
+  }
+
   bool empty() const { return unknown_.empty(); }
   size_t size() const { return unknown_.size(); }
   void Clear() { unknown_.clear(); }
@@ -1314,6 +1343,17 @@ class MetadataMap {
     }
   }
 
+  // Filter the metadata map.
+  // Iterates over all encodable and unknown headers and calls the filter_fn
+  // for each of them. If the function returns true, the header is kept.
+  template <typename Filterer>
+  void Filter(Filterer filter_fn) {
+    table_.template FilterIn<metadata_detail::FilterWrapper<Filterer>,
+                             Value<Traits>...>(
+        metadata_detail::FilterWrapper<Filterer>{filter_fn});
+    unknown_.Filter<Filterer>(&filter_fn);
+  }
+
   std::string DebugString() const {
     metadata_detail::DebugStringBuilder builder;
     Log([&builder](absl::string_view key, absl::string_view value) {

data/src/core/lib/transport/timeout_encoding.cc

@@ -23,7 +23,6 @@
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 

data/src/core/lib/transport/transport.h

@@ -190,10 +190,9 @@ void grpc_stream_ref_init(grpc_stream_refcount* refcount, int initial_refs,
 #ifndef NDEBUG
 inline void grpc_stream_ref(grpc_stream_refcount* refcount,
                             const char* reason) {
-  if (GRPC_TRACE_FLAG_ENABLED(stream_refcount)) {
-    VLOG(2) << refcount->object_type << " " << refcount << ":"
-            << refcount->destroy.cb_arg << " REF " << reason;
-  }
+  GRPC_TRACE_VLOG(stream_refcount, 2)
+      << refcount->object_type << " " << refcount << ":"
+      << refcount->destroy.cb_arg << " REF " << reason;
   refcount->refs.RefNonZero(DEBUG_LOCATION, reason);
 }
 #else
@@ -207,10 +206,9 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount);
 #ifndef NDEBUG
 inline void grpc_stream_unref(grpc_stream_refcount* refcount,
                               const char* reason) {
-  if (GRPC_TRACE_FLAG_ENABLED(stream_refcount)) {
-    VLOG(2) << refcount->object_type << " " << refcount << ":"
-            << refcount->destroy.cb_arg << " UNREF " << reason;
-  }
+  GRPC_TRACE_VLOG(stream_refcount, 2)
+      << refcount->object_type << " " << refcount << ":"
+      << refcount->destroy.cb_arg << " UNREF " << reason;
   if (GPR_UNLIKELY(refcount->refs.Unref(DEBUG_LOCATION, reason))) {
     grpc_stream_destroy(refcount);
   }

data/src/core/lib/transport/transport_op_string.cc

@@ -22,7 +22,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_fwd.h"

data/src/core/lib/uri/uri_parser.cc

@@ -36,7 +36,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {