grpc 1.53.0.pre2 → 1.54.0

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

@@ -36,7 +36,14 @@ typedef enum {
   /// Value is a \a census_context.
   GRPC_CONTEXT_TRACING,
 
-  /// Value is a CallTracer object.
+  /// Value is a CallTracerAnnotationInterface. (ClientCallTracer object on the
+  /// client-side call, or ServerCallTracer on the server-side.)
+  GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE,
+
+  /// Value is a CallTracerInterface (ServerCallTracer on the server-side,
+  /// CallAttemptTracer on a subchannel call.)
+  /// TODO(yashykt): Maybe come up with a better name. This will go away in the
+  /// future anyway, so not super important.
   GRPC_CONTEXT_CALL_TRACER,
 
   /// Reserved for traffic_class_context.

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

@@ -16,6 +16,8 @@
 
 #include "src/core/lib/channel/promise_based_filter.h"
 
+#include <inttypes.h>
+
 #include <algorithm>
 #include <initializer_list>
 #include <memory>
@@ -52,7 +54,7 @@ class FakeActivity final : public Activity {
   explicit FakeActivity(Activity* wake_activity)
       : wake_activity_(wake_activity) {}
   void Orphan() override {}
-  void ForceImmediateRepoll() override {}
+  void ForceImmediateRepoll(WakeupMask) override {}
   Waker MakeOwningWaker() override { return wake_activity_->MakeOwningWaker(); }
   Waker MakeNonOwningWaker() override {
     return wake_activity_->MakeNonOwningWaker();
@@ -91,6 +93,9 @@ BaseCallData::BaseCallData(
       arena_(args->arena),
       call_combiner_(args->call_combiner),
       deadline_(args->deadline),
+      call_context_(flags & kFilterExaminesCallContext
+                        ? arena_->New<CallContext>(nullptr)
+                        : nullptr),
       context_(args->context),
       server_initial_metadata_pipe_(
           flags & kFilterExaminesServerInitialMetadata
@@ -133,20 +138,22 @@ Waker BaseCallData::MakeNonOwningWaker() { return MakeOwningWaker(); }
 
 Waker BaseCallData::MakeOwningWaker() {
   GRPC_CALL_STACK_REF(call_stack_, "waker");
-  return Waker(this, nullptr);
+  return Waker(this, 0);
 }
 
-void BaseCallData::Wakeup(void*) {
+void BaseCallData::Wakeup(WakeupMask) {
   auto wakeup = [](void* p, grpc_error_handle) {
     auto* self = static_cast<BaseCallData*>(p);
     self->OnWakeup();
-    self->Drop(nullptr);
+    self->Drop(0);
   };
   auto* closure = GRPC_CLOSURE_CREATE(wakeup, this, nullptr);
   GRPC_CALL_COMBINER_START(call_combiner_, closure, absl::OkStatus(), "wakeup");
 }
 
-void BaseCallData::Drop(void*) { GRPC_CALL_STACK_UNREF(call_stack_, "waker"); }
+void BaseCallData::Drop(WakeupMask) {
+  GRPC_CALL_STACK_UNREF(call_stack_, "waker");
+}
 
 std::string BaseCallData::LogTag() const {
   return absl::StrCat(
@@ -214,7 +221,7 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
     // refcnt==0 ==> cancelled
     if (grpc_trace_channel.enabled()) {
       gpr_log(GPR_INFO, "%sRESUME BATCH REQUEST CANCELLED",
-              Activity::current()->DebugTag().c_str());
+              releaser->call()->DebugTag().c_str());
     }
     return;
   }
@@ -238,6 +245,10 @@ void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
   auto* batch = std::exchange(batch_, nullptr);
   GPR_ASSERT(batch != nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
+  gpr_log(GPR_DEBUG, "%sCancelWith: %p refs=%" PRIdPTR " err=%s [%s]",
+          releaser->call()->DebugTag().c_str(), batch, refcnt,
+          error.ToString().c_str(),
+          grpc_transport_stream_op_batch_string(batch, false).c_str());
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
     if (grpc_trace_channel.enabled()) {
@@ -274,16 +285,20 @@ BaseCallData::Flusher::~Flusher() {
         static_cast<BaseCallData*>(batch->handler_private.extra_arg);
     if (grpc_trace_channel.enabled()) {
       gpr_log(GPR_INFO, "FLUSHER:forward batch via closure: %s",
-              grpc_transport_stream_op_batch_string(batch).c_str());
+              grpc_transport_stream_op_batch_string(batch, false).c_str());
     }
     grpc_call_next_op(call->elem(), batch);
     GRPC_CALL_STACK_UNREF(call->call_stack(), "flusher_batch");
   };
   for (size_t i = 1; i < release_.size(); i++) {
     auto* batch = release_[i];
+    if (call_->call_context_ != nullptr && call_->call_context_->traced()) {
+      batch->is_traced = true;
+    }
     if (grpc_trace_channel.enabled()) {
-      gpr_log(GPR_INFO, "FLUSHER:queue batch to forward in closure: %s",
-              grpc_transport_stream_op_batch_string(release_[i]).c_str());
+      gpr_log(
+          GPR_INFO, "FLUSHER:queue batch to forward in closure: %s",
+          grpc_transport_stream_op_batch_string(release_[i], false).c_str());
     }
     batch->handler_private.extra_arg = call_;
     GRPC_CLOSURE_INIT(&batch->handler_private.closure, call_next_op, batch,
@@ -295,7 +310,7 @@ BaseCallData::Flusher::~Flusher() {
   call_closures_.RunClosuresWithoutYielding(call_->call_combiner());
   if (grpc_trace_channel.enabled()) {
     gpr_log(GPR_INFO, "FLUSHER:forward batch: %s",
-            grpc_transport_stream_op_batch_string(release_[0]).c_str());
+            grpc_transport_stream_op_batch_string(release_[0], false).c_str());
   }
   grpc_call_next_op(call_->elem(), release_[0]);
   GRPC_CALL_STACK_UNREF(call_->call_stack(), "flusher");
@@ -324,6 +339,8 @@ const char* BaseCallData::SendMessage::StateString(State state) {
       return "CANCELLED";
     case State::kCancelledButNotYetPolled:
       return "CANCELLED_BUT_NOT_YET_POLLED";
+    case State::kCancelledButNoStatus:
+      return "CANCELLED_BUT_NO_STATUS";
   }
   return "UNKNOWN";
 }
@@ -348,6 +365,7 @@ void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
     case State::kCancelled:
     case State::kCancelledButNotYetPolled:
+    case State::kCancelledButNoStatus:
       return;
   }
   batch_ = batch;
@@ -375,6 +393,7 @@ void BaseCallData::SendMessage::GotPipe(T* pipe_end) {
     case State::kForwardedBatch:
     case State::kBatchCompleted:
     case State::kPushedToPipe:
+    case State::kCancelledButNoStatus:
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
     case State::kCancelled:
     case State::kCancelledButNotYetPolled:
@@ -390,6 +409,7 @@ bool BaseCallData::SendMessage::IsIdle() const {
     case State::kForwardedBatch:
     case State::kCancelled:
     case State::kCancelledButNotYetPolled:
+    case State::kCancelledButNoStatus:
       return true;
     case State::kGotBatchNoPipe:
     case State::kGotBatch:
@@ -418,6 +438,7 @@ void BaseCallData::SendMessage::OnComplete(absl::Status status) {
       break;
     case State::kCancelled:
     case State::kCancelledButNotYetPolled:
+    case State::kCancelledButNoStatus:
       flusher.AddClosure(intercepted_on_complete_, status,
                          "forward after cancel");
       break;
@@ -442,10 +463,14 @@ void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
     case State::kCancelledButNotYetPolled:
       break;
     case State::kInitial:
+      state_ = State::kCancelled;
+      break;
     case State::kIdle:
     case State::kForwardedBatch:
       state_ = State::kCancelledButNotYetPolled;
+      if (base_->is_current()) base_->ForceImmediateRepoll();
       break;
+    case State::kCancelledButNoStatus:
     case State::kGotBatchNoPipe:
     case State::kGotBatch: {
       std::string temp;
@@ -464,6 +489,7 @@ void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
       push_.reset();
       next_.reset();
       state_ = State::kCancelledButNotYetPolled;
+      if (base_->is_current()) base_->ForceImmediateRepoll();
       break;
   }
 }
@@ -482,6 +508,7 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
     case State::kIdle:
     case State::kGotBatchNoPipe:
     case State::kCancelled:
+    case State::kCancelledButNoStatus:
       break;
     case State::kCancelledButNotYetPolled:
       interceptor()->Push()->Close();
@@ -523,13 +550,18 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
                   "result.has_value=%s",
                   base_->LogTag().c_str(), p->has_value() ? "true" : "false");
         }
-        GPR_ASSERT(p->has_value());
-        batch_->payload->send_message.send_message->Swap((**p)->payload());
-        batch_->payload->send_message.flags = (**p)->flags();
-        state_ = State::kForwardedBatch;
-        batch_.ResumeWith(flusher);
-        next_.reset();
-        if ((*push_)().ready()) push_.reset();
+        if (p->has_value()) {
+          batch_->payload->send_message.send_message->Swap((**p)->payload());
+          batch_->payload->send_message.flags = (**p)->flags();
+          state_ = State::kForwardedBatch;
+          batch_.ResumeWith(flusher);
+          next_.reset();
+          if ((*push_)().ready()) push_.reset();
+        } else {
+          state_ = State::kCancelledButNoStatus;
+          next_.reset();
+          push_.reset();
+        }
       }
     } break;
     case State::kForwardedBatch:
@@ -1087,11 +1119,14 @@ class ClientCallData::PollContext {
         // Poll the promise once since we're waiting for it.
         Poll<ServerMetadataHandle> poll = self_->promise_();
         if (grpc_trace_channel.enabled()) {
-          gpr_log(GPR_INFO, "%s ClientCallData.PollContext.Run: poll=%s",
+          gpr_log(GPR_INFO, "%s ClientCallData.PollContext.Run: poll=%s; %s",
                   self_->LogTag().c_str(),
-                  PollToString(poll, [](const ServerMetadataHandle& h) {
-                    return h->DebugString();
-                  }).c_str());
+                  PollToString(poll,
+                               [](const ServerMetadataHandle& h) {
+                                 return h->DebugString();
+                               })
+                      .c_str(),
+                  self_->DebugString().c_str());
         }
         if (auto* r = poll.value_if_ready()) {
           auto md = std::move(*r);
@@ -1271,7 +1306,11 @@ ClientCallData::ClientCallData(grpc_call_element* elem,
           [args]() {
             return args->arena->New<ReceiveInterceptor>(args->arena);
           },
-          [args]() { return args->arena->New<SendInterceptor>(args->arena); }) {
+          [args]() { return args->arena->New<SendInterceptor>(args->arena); }),
+      initial_metadata_outstanding_token_(
+          (flags & kFilterIsLast) != 0
+              ? ClientInitialMetadataOutstandingToken::New(arena())
+              : ClientInitialMetadataOutstandingToken::Empty()) {
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_,
                     RecvTrailingMetadataReadyCallback, this,
                     grpc_schedule_on_exec_ctx);
@@ -1287,8 +1326,12 @@ ClientCallData::~ClientCallData() {
   }
 }
 
+std::string ClientCallData::DebugTag() const {
+  return absl::StrFormat("PBF_CLIENT[%p]: [%s] ", this, elem()->filter->name);
+}
+
 // Activity implementation.
-void ClientCallData::ForceImmediateRepoll() {
+void ClientCallData::ForceImmediateRepoll(WakeupMask) {
   GPR_ASSERT(poll_ctx_ != nullptr);
   poll_ctx_->Repoll();
 }
@@ -1540,6 +1583,7 @@ void ClientCallData::StartPromise(Flusher* flusher) {
   promise_ = filter->MakeCallPromise(
       CallArgs{WrapMetadata(send_initial_metadata_batch_->payload
                                 ->send_initial_metadata.send_initial_metadata),
+               std::move(initial_metadata_outstanding_token_),
                server_initial_metadata_pipe() == nullptr
                    ? nullptr
                    : &server_initial_metadata_pipe()->sender,
@@ -1647,8 +1691,7 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
   GPR_ASSERT(poll_ctx_ != nullptr);
   GPR_ASSERT(send_initial_state_ == SendInitialState::kQueued);
   send_initial_metadata_batch_->payload->send_initial_metadata
-      .send_initial_metadata =
-      UnwrapMetadata(std::move(call_args.client_initial_metadata));
+      .send_initial_metadata = call_args.client_initial_metadata.get();
   if (recv_initial_metadata_ != nullptr) {
     // Call args should contain a latch for receiving initial metadata.
     // It might be the one we passed in - in which case we know this filter
@@ -1860,8 +1903,15 @@ struct ServerCallData::SendInitialMetadata {
 
 class ServerCallData::PollContext {
  public:
-  explicit PollContext(ServerCallData* self, Flusher* flusher)
-      : self_(self), flusher_(flusher) {
+  explicit PollContext(ServerCallData* self, Flusher* flusher,
+                       DebugLocation created = DebugLocation())
+      : self_(self), flusher_(flusher), created_(created) {
+    if (self_->poll_ctx_ != nullptr) {
+      Crash(absl::StrCat(
+          "PollContext: disallowed recursion. New: ", created_.file(), ":",
+          created_.line(), "; Old: ", self_->poll_ctx_->created_.file(), ":",
+          self_->poll_ctx_->created_.line()));
+    }
     GPR_ASSERT(self_->poll_ctx_ == nullptr);
     self_->poll_ctx_ = this;
     scoped_activity_.Init(self_);
@@ -1907,6 +1957,7 @@ class ServerCallData::PollContext {
   Flusher* const flusher_;
   bool repoll_ = false;
   bool have_scoped_activity_;
+  GPR_NO_UNIQUE_ADDRESS DebugLocation created_;
 };
 
 const char* ServerCallData::StateString(RecvInitialState state) {
@@ -1966,11 +2017,18 @@ ServerCallData::~ServerCallData() {
     gpr_log(GPR_INFO, "%s ~ServerCallData %s", LogTag().c_str(),
             DebugString().c_str());
   }
+  if (send_initial_metadata_ != nullptr) {
+    send_initial_metadata_->~SendInitialMetadata();
+  }
   GPR_ASSERT(poll_ctx_ == nullptr);
 }
 
+std::string ServerCallData::DebugTag() const {
+  return absl::StrFormat("PBF_SERVER[%p]: [%s] ", this, elem()->filter->name);
+}
+
 // Activity implementation.
-void ServerCallData::ForceImmediateRepoll() {
+void ServerCallData::ForceImmediateRepoll(WakeupMask) {
   GPR_ASSERT(poll_ctx_ != nullptr);
   poll_ctx_->Repoll();
 }
@@ -2076,7 +2134,10 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
     switch (send_trailing_state_) {
       case SendTrailingState::kInitial:
         send_trailing_metadata_batch_ = batch;
-        if (receive_message() != nullptr) {
+        if (receive_message() != nullptr &&
+            batch->payload->send_trailing_metadata.send_trailing_metadata
+                    ->get(GrpcStatusMetadata())
+                    .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
           receive_message()->Done(
               *batch->payload->send_trailing_metadata.send_trailing_metadata,
               &flusher);
@@ -2133,9 +2194,12 @@ void ServerCallData::Completed(grpc_error_handle error, Flusher* flusher) {
     case SendTrailingState::kForwarded:
       send_trailing_state_ = SendTrailingState::kCancelled;
       if (!error.ok()) {
+        call_stack()->IncrementRefCount();
         auto* batch = grpc_make_transport_stream_op(
-            NewClosure([call_combiner = call_combiner()](absl::Status) {
+            NewClosure([call_combiner = call_combiner(),
+                        call_stack = call_stack()](absl::Status) {
               GRPC_CALL_COMBINER_STOP(call_combiner, "done-cancel");
+              call_stack->Unref();
             }));
         batch->cancel_stream = true;
         batch->payload->cancel_stream.cancel_error = error;
@@ -2187,7 +2251,7 @@ void ServerCallData::Completed(grpc_error_handle error, Flusher* flusher) {
 ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
     CallArgs call_args) {
   GPR_ASSERT(recv_initial_state_ == RecvInitialState::kComplete);
-  GPR_ASSERT(UnwrapMetadata(std::move(call_args.client_initial_metadata)) ==
+  GPR_ASSERT(std::move(call_args.client_initial_metadata).get() ==
              recv_initial_metadata_);
   forward_recv_initial_metadata_callback_ = true;
   if (send_initial_metadata_ != nullptr) {
@@ -2309,6 +2373,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   FakeActivity(this).Run([this, filter] {
     promise_ = filter->MakeCallPromise(
         CallArgs{WrapMetadata(recv_initial_metadata_),
+                 ClientInitialMetadataOutstandingToken::Empty(),
                  server_initial_metadata_pipe() == nullptr
                      ? nullptr
                      : &server_initial_metadata_pipe()->sender,
@@ -2409,9 +2474,14 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
          (send_trailing_metadata_batch_->send_message &&
           send_message()->IsForwarded()))) {
       send_trailing_state_ = SendTrailingState::kQueued;
-      send_message()->Done(*send_trailing_metadata_batch_->payload
-                                ->send_trailing_metadata.send_trailing_metadata,
-                           flusher);
+      if (send_trailing_metadata_batch_->payload->send_trailing_metadata
+              .send_trailing_metadata->get(GrpcStatusMetadata())
+              .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
+        send_message()->Done(
+            *send_trailing_metadata_batch_->payload->send_trailing_metadata
+                 .send_trailing_metadata,
+            flusher);
+      }
     }
   }
   if (receive_message() != nullptr) {
@@ -2462,8 +2532,7 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
     }
     if (auto* r = poll.value_if_ready()) {
       promise_ = ArenaPromise<ServerMetadataHandle>();
-      auto* md = UnwrapMetadata(std::move(*r));
-      bool destroy_md = true;
+      auto md = std::move(*r);
       if (send_message() != nullptr) {
         send_message()->Done(*md, flusher);
       }
@@ -2475,11 +2544,9 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
         case SendTrailingState::kQueuedButHaventClosedSends:
         case SendTrailingState::kQueued: {
           if (send_trailing_metadata_batch_->payload->send_trailing_metadata
-                  .send_trailing_metadata != md) {
+                  .send_trailing_metadata != md.get()) {
             *send_trailing_metadata_batch_->payload->send_trailing_metadata
                  .send_trailing_metadata = std::move(*md);
-          } else {
-            destroy_md = false;
           }
           send_trailing_metadata_batch_.ResumeWith(flusher);
           send_trailing_state_ = SendTrailingState::kForwarded;
@@ -2497,9 +2564,6 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
           // Nothing to do.
           break;
       }
-      if (destroy_md) {
-        md->~grpc_metadata_batch();
-      }
     }
   }
   if (std::exchange(forward_recv_initial_metadata_callback_, false)) {

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

@@ -62,6 +62,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/surface/call.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -134,6 +135,7 @@ static constexpr uint8_t kFilterExaminesServerInitialMetadata = 1;
 static constexpr uint8_t kFilterIsLast = 2;
 static constexpr uint8_t kFilterExaminesOutboundMessages = 4;
 static constexpr uint8_t kFilterExaminesInboundMessages = 8;
+static constexpr uint8_t kFilterExaminesCallContext = 16;
 
 namespace promise_filter_detail {
 
@@ -182,7 +184,7 @@ class BaseCallData : public Activity, private Wakeable {
   Waker MakeNonOwningWaker() final;
   Waker MakeOwningWaker() final;
 
-  std::string ActivityDebugTag(void*) const override { return DebugTag(); }
+  std::string ActivityDebugTag(WakeupMask) const override { return DebugTag(); }
 
   void Finalize(const grpc_call_final_info* final_info) {
     finalization_.Run(final_info);
@@ -197,7 +199,8 @@ class BaseCallData : public Activity, private Wakeable {
         public promise_detail::Context<grpc_polling_entity>,
         public promise_detail::Context<CallFinalization>,
         public promise_detail::Context<
-            grpc_event_engine::experimental::EventEngine> {
+            grpc_event_engine::experimental::EventEngine>,
+        public promise_detail::Context<CallContext> {
    public:
     explicit ScopedContext(BaseCallData* call_data)
         : promise_detail::Context<Arena>(call_data->arena_),
@@ -207,7 +210,8 @@ class BaseCallData : public Activity, private Wakeable {
               call_data->pollent_.load(std::memory_order_acquire)),
           promise_detail::Context<CallFinalization>(&call_data->finalization_),
           promise_detail::Context<grpc_event_engine::experimental::EventEngine>(
-              call_data->event_engine_) {}
+              call_data->event_engine_),
+          promise_detail::Context<CallContext>(call_data->call_context_) {}
   };
 
   class Flusher {
@@ -218,7 +222,11 @@ class BaseCallData : public Activity, private Wakeable {
 
     void Resume(grpc_transport_stream_op_batch* batch) {
       GPR_ASSERT(!call_->is_last());
-      release_.push_back(batch);
+      if (batch->HasOp()) {
+        release_.push_back(batch);
+      } else if (batch->on_complete != nullptr) {
+        Complete(batch);
+      }
     }
 
     void Cancel(grpc_transport_stream_op_batch* batch,
@@ -237,6 +245,8 @@ class BaseCallData : public Activity, private Wakeable {
       call_closures_.Add(closure, error, reason);
     }
 
+    BaseCallData* call() const { return call_; }
+
    private:
     absl::InlinedVector<grpc_transport_stream_op_batch*, 1> release_;
     CallCombinerClosureList call_closures_;
@@ -280,11 +290,6 @@ class BaseCallData : public Activity, private Wakeable {
                                                Arena::PooledDeleter(nullptr));
   }
 
-  static grpc_metadata_batch* UnwrapMetadata(
-      Arena::PoolPtr<grpc_metadata_batch> p) {
-    return p.release();
-  }
-
   class ReceiveInterceptor final : public Interceptor {
    public:
     explicit ReceiveInterceptor(Arena* arena) : pipe_{arena} {}
@@ -398,6 +403,8 @@ class BaseCallData : public Activity, private Wakeable {
       kCancelledButNotYetPolled,
       // We're done.
       kCancelled,
+      // We're done, but we haven't gotten a status yet
+      kCancelledButNoStatus,
     };
     static const char* StateString(State);
 
@@ -538,8 +545,8 @@ class BaseCallData : public Activity, private Wakeable {
 
  private:
   // Wakeable implementation.
-  void Wakeup(void*) final;
-  void Drop(void*) final;
+  void Wakeup(WakeupMask) final;
+  void Drop(WakeupMask) final;
 
   virtual void OnWakeup() = 0;
 
@@ -549,6 +556,7 @@ class BaseCallData : public Activity, private Wakeable {
   CallCombiner* const call_combiner_;
   const Timestamp deadline_;
   CallFinalization finalization_;
+  CallContext* call_context_ = nullptr;
   grpc_call_context_element* const context_;
   std::atomic<grpc_polling_entity*> pollent_{nullptr};
   Pipe<ServerMetadataHandle>* const server_initial_metadata_pipe_;
@@ -564,10 +572,12 @@ class ClientCallData : public BaseCallData {
   ~ClientCallData() override;
 
   // Activity implementation.
-  void ForceImmediateRepoll() final;
+  void ForceImmediateRepoll(WakeupMask) final;
   // Handle one grpc_transport_stream_op_batch
   void StartBatch(grpc_transport_stream_op_batch* batch) override;
 
+  std::string DebugTag() const override;
+
  private:
   // At what stage is our handling of send initial metadata?
   enum class SendInitialState {
@@ -664,6 +674,8 @@ class ClientCallData : public BaseCallData {
   RecvTrailingState recv_trailing_state_ = RecvTrailingState::kInitial;
   // Polling related data. Non-null if we're actively polling
   PollContext* poll_ctx_ = nullptr;
+  // Initial metadata outstanding token
+  ClientInitialMetadataOutstandingToken initial_metadata_outstanding_token_;
 };
 
 class ServerCallData : public BaseCallData {
@@ -673,10 +685,12 @@ class ServerCallData : public BaseCallData {
   ~ServerCallData() override;
 
   // Activity implementation.
-  void ForceImmediateRepoll() final;
+  void ForceImmediateRepoll(WakeupMask) final;
   // Handle one grpc_transport_stream_op_batch
   void StartBatch(grpc_transport_stream_op_batch* batch) override;
 
+  std::string DebugTag() const override;
+
  protected:
   absl::string_view ClientOrServerString() const override { return "SVR"; }
 

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

@@ -0,0 +1,110 @@
+//
+// Copyright 2023 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/call_finalization.h"
+#include "src/core/lib/channel/call_tracer.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/cancel_callback.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+namespace {
+
+// TODO(yashykt): This filter is not really needed. We should be able to move
+// this to the connected filter.
+class ServerCallTracerFilter : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ServerCallTracerFilter> Create(
+      const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/);
+
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+};
+
+const grpc_channel_filter ServerCallTracerFilter::kFilter =
+    MakePromiseBasedFilter<ServerCallTracerFilter, FilterEndpoint::kServer,
+                           kFilterExaminesServerInitialMetadata>(
+        "server_call_tracer");
+
+absl::StatusOr<ServerCallTracerFilter> ServerCallTracerFilter::Create(
+    const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/) {
+  return ServerCallTracerFilter();
+}
+
+ArenaPromise<ServerMetadataHandle> ServerCallTracerFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  auto* call_context = GetContext<grpc_call_context_element>();
+  auto* call_tracer = static_cast<ServerCallTracer*>(
+      call_context[GRPC_CONTEXT_CALL_TRACER].value);
+  if (call_tracer == nullptr) {
+    return next_promise_factory(std::move(call_args));
+  }
+  call_tracer->RecordReceivedInitialMetadata(
+      call_args.client_initial_metadata.get());
+  call_args.server_initial_metadata->InterceptAndMap(
+      [call_tracer](ServerMetadataHandle metadata) {
+        call_tracer->RecordSendInitialMetadata(metadata.get());
+        return metadata;
+      });
+  GetContext<CallFinalization>()->Add(
+      [call_tracer](const grpc_call_final_info* final_info) {
+        call_tracer->RecordEnd(final_info);
+      });
+  return OnCancel(
+      Map(next_promise_factory(std::move(call_args)),
+          [call_tracer](ServerMetadataHandle md) {
+            call_tracer->RecordSendTrailingMetadata(md.get());
+            return md;
+          }),
+      [call_tracer]() { call_tracer->RecordCancel(absl::CancelledError()); });
+}
+
+}  // namespace
+
+void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+      [](ChannelStackBuilder* builder) {
+        builder->AppendFilter(&ServerCallTracerFilter::kFilter);
+        return true;
+      });
+}
+
+}  // namespace grpc_core