grpc 1.65.2 → 1.66.0.pre3

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

@@ -23,6 +23,7 @@
 #include "absl/base/attributes.h"
 #include "absl/functional/function_ref.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -99,11 +100,7 @@ BaseCallData::BaseCallData(
       receive_message_(
           flags & kFilterExaminesInboundMessages
               ? arena_->New<ReceiveMessage>(this, make_recv_interceptor())
-              : nullptr),
-      event_engine_(
-          ChannelFilterFromElem(elem)
-              ->hack_until_per_channel_stack_event_engines_land_get_event_engine()) {
-}
+              : nullptr) {}
 
 BaseCallData::~BaseCallData() {
   FakeActivity(this).Run([this] {
@@ -211,8 +208,8 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(GPR_INFO, "%sRESUME BATCH REQUEST CANCELLED",
-              releaser->call()->DebugTag().c_str());
+      LOG(INFO) << releaser->call()->DebugTag()
+                << "RESUME BATCH REQUEST CANCELLED";
     }
     return;
   }
@@ -267,8 +264,8 @@ BaseCallData::Flusher::~Flusher() {
     BaseCallData* call =
         static_cast<BaseCallData*>(batch->handler_private.extra_arg);
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(GPR_INFO, "FLUSHER:forward batch via closure: %s",
-              grpc_transport_stream_op_batch_string(batch, false).c_str());
+      LOG(INFO) << "FLUSHER:forward batch via closure: "
+                << grpc_transport_stream_op_batch_string(batch, false);
     }
     grpc_call_next_op(call->elem(), batch);
     GRPC_CALL_STACK_UNREF(call->call_stack(), "flusher_batch");
@@ -279,9 +276,8 @@ BaseCallData::Flusher::~Flusher() {
       batch->is_traced = true;
     }
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(
-          GPR_INFO, "FLUSHER:queue batch to forward in closure: %s",
-          grpc_transport_stream_op_batch_string(release_[i], false).c_str());
+      LOG(INFO) << "FLUSHER:queue batch to forward in closure: "
+                << grpc_transport_stream_op_batch_string(release_[i], false);
     }
     batch->handler_private.extra_arg = call_;
     GRPC_CLOSURE_INIT(&batch->handler_private.closure, call_next_op, batch,
@@ -292,8 +288,8 @@ BaseCallData::Flusher::~Flusher() {
   }
   call_closures_.RunClosuresWithoutYielding(call_->call_combiner());
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "FLUSHER:forward batch: %s",
-            grpc_transport_stream_op_batch_string(release_[0], false).c_str());
+    LOG(INFO) << "FLUSHER:forward batch: "
+              << grpc_transport_stream_op_batch_string(release_[0], false);
   }
   if (call_->call() != nullptr && call_->call()->traced()) {
     release_[0]->is_traced = true;
@@ -333,8 +329,8 @@ const char* BaseCallData::SendMessage::StateString(State state) {
 
 void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s SendMessage.StartOp st=%s", base_->LogTag().c_str(),
-            StateString(state_));
+    LOG(INFO) << base_->LogTag()
+              << " SendMessage.StartOp st=" << StateString(state_);
   }
   switch (state_) {
     case State::kInitial:
@@ -361,8 +357,8 @@ void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
 template <typename T>
 void BaseCallData::SendMessage::GotPipe(T* pipe_end) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s SendMessage.GotPipe st=%s", base_->LogTag().c_str(),
-            StateString(state_));
+    LOG(INFO) << base_->LogTag()
+              << " SendMessage.GotPipe st=" << StateString(state_);
   }
   CHECK_NE(pipe_end, nullptr);
   switch (state_) {
@@ -409,9 +405,9 @@ bool BaseCallData::SendMessage::IsIdle() const {
 void BaseCallData::SendMessage::OnComplete(absl::Status status) {
   Flusher flusher(base_);
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s SendMessage.OnComplete st=%s status=%s",
-            base_->LogTag().c_str(), StateString(state_),
-            status.ToString().c_str());
+    LOG(INFO) << base_->LogTag()
+              << " SendMessage.OnComplete st=" << StateString(state_)
+              << " status=" << status;
   }
   switch (state_) {
     case State::kInitial:
@@ -440,9 +436,9 @@ void BaseCallData::SendMessage::OnComplete(absl::Status status) {
 void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
                                      Flusher* flusher) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s SendMessage.Done st=%s md=%s",
-            base_->LogTag().c_str(), StateString(state_),
-            metadata.DebugString().c_str());
+    LOG(INFO) << base_->LogTag()
+              << " SendMessage.Done st=" << StateString(state_)
+              << " md=" << metadata.DebugString();
   }
   switch (state_) {
     case State::kCancelled:
@@ -483,11 +479,11 @@ void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
 void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
                                                    bool allow_push_to_pipe) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s SendMessage.WakeInsideCombiner st=%s%s",
-            base_->LogTag().c_str(), StateString(state_),
-            state_ == State::kBatchCompleted
-                ? absl::StrCat(" status=", completed_status_.ToString()).c_str()
-                : "");
+    LOG(INFO) << base_->LogTag()
+              << " SendMessage.WakeInsideCombiner st=" << StateString(state_)
+              << (state_ == State::kBatchCompleted
+                      ? absl::StrCat(" status=", completed_status_.ToString())
+                      : "");
   }
   switch (state_) {
     case State::kInitial:
@@ -517,9 +513,10 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO,
-                  "%s SendMessage.WakeInsideCombiner push complete, result=%s",
-                  base_->LogTag().c_str(), *p ? "true" : "false");
+          LOG(INFO) << base_->LogTag()
+                    << " SendMessage.WakeInsideCombiner push complete, "
+                       "result="
+                    << (*p ? "true" : "false");
         }
         // We haven't pulled through yet, so this certainly shouldn't succeed.
         CHECK(!*p);
@@ -531,10 +528,10 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       auto r_next = (*next_)();
       if (auto* p = r_next.value_if_ready()) {
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO,
-                  "%s SendMessage.WakeInsideCombiner next complete, "
-                  "result.has_value=%s",
-                  base_->LogTag().c_str(), p->has_value() ? "true" : "false");
+          LOG(INFO) << base_->LogTag()
+                    << " SendMessage.WakeInsideCombiner next complete, "
+                       "result.has_value="
+                    << (p->has_value() ? "true" : "false");
         }
         if (p->has_value()) {
           batch_->payload->send_message.send_message->Swap((**p)->payload());
@@ -616,8 +613,8 @@ const char* BaseCallData::ReceiveMessage::StateString(State state) {
 
 void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ReceiveMessage.StartOp st=%s",
-            base_->LogTag().c_str(), StateString(state_));
+    LOG(INFO) << base_->LogTag()
+              << " ReceiveMessage.StartOp st=" << StateString(state_);
   }
   switch (state_) {
     case State::kInitial:
@@ -657,8 +654,8 @@ void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
 template <typename T>
 void BaseCallData::ReceiveMessage::GotPipe(T* pipe_end) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ReceiveMessage.GotPipe st=%s",
-            base_->LogTag().c_str(), StateString(state_));
+    LOG(INFO) << base_->LogTag()
+              << " ReceiveMessage.GotPipe st=" << StateString(state_);
   }
   switch (state_) {
     case State::kInitial:
@@ -693,9 +690,9 @@ void BaseCallData::ReceiveMessage::GotPipe(T* pipe_end) {
 
 void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ReceiveMessage.OnComplete st=%s status=%s",
-            base_->LogTag().c_str(), StateString(state_),
-            status.ToString().c_str());
+    LOG(INFO) << base_->LogTag()
+              << " ReceiveMessage.OnComplete st=" << StateString(state_)
+              << " status=" << status;
   }
   switch (state_) {
     case State::kInitial:
@@ -734,9 +731,9 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
 void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
                                         Flusher* flusher) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ReceiveMessage.Done st=%s md=%s",
-            base_->LogTag().c_str(), StateString(state_),
-            metadata.DebugString().c_str());
+    LOG(INFO) << base_->LogTag()
+              << " ReceiveMessage.Done st=" << StateString(state_)
+              << " md=" << metadata.DebugString();
   }
   switch (state_) {
     case State::kInitial:
@@ -793,12 +790,11 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
 void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
                                                       bool allow_push_to_pipe) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO,
-            "%s ReceiveMessage.WakeInsideCombiner st=%s push?=%s next?=%s "
-            "allow_push_to_pipe=%s",
-            base_->LogTag().c_str(), StateString(state_),
-            push_.has_value() ? "yes" : "no", next_.has_value() ? "yes" : "no",
-            allow_push_to_pipe ? "yes" : "no");
+    LOG(INFO) << base_->LogTag()
+              << " ReceiveMessage.WakeInsideCombiner st=" << StateString(state_)
+              << " push?=" << (push_.has_value() ? "yes" : "no")
+              << " next?=" << (next_.has_value() ? "yes" : "no")
+              << " allow_push_to_pipe=" << (allow_push_to_pipe ? "yes" : "no");
   }
   switch (state_) {
     case State::kInitial:
@@ -855,9 +851,9 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO,
-                  "%s ReceiveMessage.WakeInsideCombiner push complete: %s",
-                  base_->LogTag().c_str(), *p ? "true" : "false");
+          LOG(INFO) << base_->LogTag()
+                    << " ReceiveMessage.WakeInsideCombiner push complete: "
+                    << (*p ? "true" : "false");
         }
         // We haven't pulled through yet, so this certainly shouldn't succeed.
         CHECK(!*p);
@@ -886,12 +882,10 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
               "recv_message");
         }
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO,
-                  "%s ReceiveMessage.WakeInsideCombiner next complete: %s "
-                  "new_state=%s",
-                  base_->LogTag().c_str(),
-                  p->has_value() ? "got message" : "end of stream",
-                  StateString(state_));
+          LOG(INFO) << base_->LogTag()
+                    << " ReceiveMessage.WakeInsideCombiner next complete: "
+                    << (p->has_value() ? "got message" : "end of stream")
+                    << " new_state=" << StateString(state_);
         }
       }
       if (state_ != State::kPulledFromPipe &&
@@ -905,9 +899,8 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       CHECK(push_.has_value());
       if ((*push_)().ready()) {
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO,
-                  "%s ReceiveMessage.WakeInsideCombiner push complete",
-                  base_->LogTag().c_str());
+          LOG(INFO) << base_->LogTag()
+                    << " ReceiveMessage.WakeInsideCombiner push complete";
         }
         if (state_ == State::kCompletedWhilePulledFromPipe) {
           interceptor()->Push()->Close();
@@ -1021,8 +1014,8 @@ class ClientCallData::PollContext {
   void Run() {
     DCHECK(HasContext<Arena>());
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(GPR_INFO, "%s ClientCallData.PollContext.Run %s",
-              self_->LogTag().c_str(), self_->DebugString().c_str());
+      LOG(INFO) << self_->LogTag() << " ClientCallData.PollContext.Run "
+                << self_->DebugString();
     }
     CHECK(have_scoped_activity_);
     repoll_ = false;
@@ -1105,14 +1098,13 @@ class ClientCallData::PollContext {
         // Poll the promise once since we're waiting for it.
         Poll<ServerMetadataHandle> poll = self_->promise_();
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          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(),
-                  self_->DebugString().c_str());
+          LOG(INFO) << self_->LogTag()
+                    << " ClientCallData.PollContext.Run: poll="
+                    << PollToString(poll,
+                                    [](const ServerMetadataHandle& h) {
+                                      return h->DebugString();
+                                    })
+                    << "; " << self_->DebugString();
         }
         if (auto* r = poll.value_if_ready()) {
           auto md = std::move(*r);
@@ -1316,7 +1308,7 @@ ClientCallData::~ClientCallData() {
 }
 
 std::string ClientCallData::DebugTag() const {
-  return absl::StrFormat("PBF_CLIENT[%p]: [%s] ", this, elem()->filter->name);
+  return absl::StrFormat("PBF_CLIENT[%p]: [%v] ", this, elem()->filter->name);
 }
 
 // Activity implementation.
@@ -1385,8 +1377,7 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   Flusher flusher(this);
 
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s StartBatch %s", LogTag().c_str(),
-            DebugString().c_str());
+    LOG(INFO) << LogTag() << " StartBatch " << DebugString();
   }
 
   // If this is a cancel stream, cancel anything we have pending and propagate
@@ -1509,8 +1500,7 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
 // Handle cancellation.
 void ClientCallData::Cancel(grpc_error_handle error, Flusher* flusher) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s Cancel error=%s", LogTag().c_str(),
-            error.ToString().c_str());
+    LOG(INFO) << LogTag() << " Cancel error=" << error.ToString();
   }
   // Track the latest reason for cancellation.
   cancelled_error_ = error;
@@ -1589,10 +1579,9 @@ void ClientCallData::StartPromise(Flusher* flusher) {
 
 void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO,
-            "%s ClientCallData.RecvInitialMetadataReady %s error:%s md:%s",
-            LogTag().c_str(), DebugString().c_str(), error.ToString().c_str(),
-            recv_initial_metadata_->metadata->DebugString().c_str());
+    LOG(INFO) << LogTag() << " ClientCallData.RecvInitialMetadataReady "
+              << DebugString() << " error:" << error.ToString()
+              << " md:" << recv_initial_metadata_->metadata->DebugString();
   }
   ScopedContext context(this);
   Flusher flusher(this);
@@ -1673,8 +1662,8 @@ void ClientCallData::HookRecvTrailingMetadata(CapturedBatch batch) {
 ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
     CallArgs call_args) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ClientCallData.MakeNextPromise %s", LogTag().c_str(),
-            DebugString().c_str());
+    LOG(INFO) << LogTag() << " ClientCallData.MakeNextPromise "
+              << DebugString();
   }
   CHECK_NE(poll_ctx_, nullptr);
   CHECK(send_initial_state_ == SendInitialState::kQueued);
@@ -1736,8 +1725,8 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
 // application.
 Poll<ServerMetadataHandle> ClientCallData::PollTrailingMetadata() {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ClientCallData.PollTrailingMetadata %s",
-            LogTag().c_str(), DebugString().c_str());
+    LOG(INFO) << LogTag() << " ClientCallData.PollTrailingMetadata "
+              << DebugString();
   }
   CHECK_NE(poll_ctx_, nullptr);
   if (send_initial_state_ == SendInitialState::kQueued) {
@@ -1787,12 +1776,10 @@ void ClientCallData::RecvTrailingMetadataReadyCallback(
 void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO,
-            "%s ClientCallData.RecvTrailingMetadataReady "
-            "recv_trailing_state=%s error=%s md=%s",
-            LogTag().c_str(), StateString(recv_trailing_state_),
-            error.ToString().c_str(),
-            recv_trailing_metadata_->DebugString().c_str());
+    LOG(INFO) << LogTag() << " ClientCallData.RecvTrailingMetadataReady "
+              << "recv_trailing_state=" << StateString(recv_trailing_state_)
+              << " error=" << error
+              << " md=" << recv_trailing_metadata_->DebugString();
   }
   // If we were cancelled prior to receiving this callback, we should simply
   // forward the callback up with the same error.
@@ -2002,8 +1989,7 @@ ServerCallData::ServerCallData(grpc_call_element* elem,
 
 ServerCallData::~ServerCallData() {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s ~ServerCallData %s", LogTag().c_str(),
-            DebugString().c_str());
+    LOG(INFO) << LogTag() << " ~ServerCallData " << DebugString();
   }
   if (send_initial_metadata_ != nullptr) {
     send_initial_metadata_->~SendInitialMetadata();
@@ -2012,7 +1998,7 @@ ServerCallData::~ServerCallData() {
 }
 
 std::string ServerCallData::DebugTag() const {
-  return absl::StrFormat("PBF_SERVER[%p]: [%s] ", this, elem()->filter->name);
+  return absl::StrFormat("PBF_SERVER[%p]: [%v] ", this, elem()->filter->name);
 }
 
 // Activity implementation.
@@ -2030,8 +2016,7 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   bool wake = false;
 
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s StartBatch: %s", LogTag().c_str(),
-            DebugString().c_str());
+    LOG(INFO) << LogTag() << " StartBatch: " << DebugString();
   }
 
   // If this is a cancel stream, cancel anything we have pending and
@@ -2164,15 +2149,13 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
 void ServerCallData::Completed(grpc_error_handle error,
                                bool tarpit_cancellation, Flusher* flusher) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(
-        GPR_DEBUG,
-        "%sServerCallData::Completed: send_trailing_state=%s "
-        "send_initial_state=%s error=%s",
-        LogTag().c_str(), StateString(send_trailing_state_),
-        send_initial_metadata_ == nullptr
-            ? "null"
-            : SendInitialMetadata::StateString(send_initial_metadata_->state),
-        error.ToString().c_str());
+    VLOG(2) << LogTag() << "ServerCallData::Completed: send_trailing_state="
+            << StateString(send_trailing_state_) << " send_initial_state="
+            << (send_initial_metadata_ == nullptr
+                    ? "null"
+                    : SendInitialMetadata::StateString(
+                          send_initial_metadata_->state))
+            << " error=" << error;
   }
   // Track the latest reason for cancellation.
   cancelled_error_ = error;
@@ -2290,8 +2273,8 @@ ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
 // stack.
 Poll<ServerMetadataHandle> ServerCallData::PollTrailingMetadata() {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s PollTrailingMetadata: %s", LogTag().c_str(),
-            StateString(send_trailing_state_));
+    LOG(INFO) << LogTag()
+              << " PollTrailingMetadata: " << StateString(send_trailing_state_);
   }
   switch (send_trailing_state_) {
     case SendTrailingState::kInitial:
@@ -2321,9 +2304,8 @@ void ServerCallData::RecvTrailingMetadataReadyCallback(
 
 void ServerCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s: RecvTrailingMetadataReady error=%s md=%s",
-            LogTag().c_str(), error.ToString().c_str(),
-            recv_trailing_metadata_->DebugString().c_str());
+    LOG(INFO) << LogTag() << ": RecvTrailingMetadataReady error=" << error
+              << " md=" << recv_trailing_metadata_->DebugString();
   }
   Flusher flusher(this);
   PollContext poll_ctx(this, &flusher);
@@ -2341,8 +2323,7 @@ void ServerCallData::RecvInitialMetadataReadyCallback(void* arg,
 void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s: RecvInitialMetadataReady %s", LogTag().c_str(),
-            error.ToString().c_str());
+    LOG(INFO) << LogTag() << ": RecvInitialMetadataReady " << error;
   }
   CHECK(recv_initial_state_ == RecvInitialState::kForwarded);
   // If there was an error we just propagate that through
@@ -2406,8 +2387,7 @@ std::string ServerCallData::DebugString() const {
 void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
   PollContext poll_ctx(this, flusher);
   if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "%s: WakeInsideCombiner %s", LogTag().c_str(),
-            DebugString().c_str());
+    LOG(INFO) << LogTag() << ": WakeInsideCombiner " << DebugString();
   }
   poll_ctx.ClearRepoll();
   if (send_initial_metadata_ != nullptr) {
@@ -2429,13 +2409,11 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
     if (send_initial_metadata_->metadata_push_.has_value()) {
       if ((*send_initial_metadata_->metadata_push_)().ready()) {
         if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          gpr_log(GPR_INFO, "%s: WakeInsideCombiner: metadata_push done",
-                  LogTag().c_str());
+          LOG(INFO) << LogTag() << ": WakeInsideCombiner: metadata_push done";
         }
         send_initial_metadata_->metadata_push_.reset();
       } else if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-        gpr_log(GPR_INFO, "%s: WakeInsideCombiner: metadata_push pending",
-                LogTag().c_str());
+        LOG(INFO) << LogTag() << ": WakeInsideCombiner: metadata_push pending";
       }
     }
   }
@@ -2452,12 +2430,9 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
         send_initial_metadata_ == nullptr ||
             send_initial_metadata_->state == SendInitialMetadata::kForwarded);
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(GPR_DEBUG,
-              "%s: After send_message WakeInsideCombiner %s is_idle=%s "
-              "is_forwarded=%s",
-              LogTag().c_str(), DebugString().c_str(),
-              send_message()->IsIdle() ? "true" : "false",
-              send_message()->IsForwarded() ? "true" : "false");
+      VLOG(2) << LogTag() << ": After send_message WakeInsideCombiner "
+              << DebugString() << " is_idle=" << send_message()->IsIdle()
+              << " is_forwarded=" << send_message()->IsForwarded();
     }
     if (send_trailing_state_ == SendTrailingState::kQueuedBehindSendMessage &&
         (send_message()->IsIdle() ||
@@ -2481,19 +2456,19 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
     Poll<ServerMetadataHandle> poll;
     poll = promise_();
     if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      gpr_log(
-          GPR_INFO,
-          "%s: WakeInsideCombiner poll=%s; send_initial_metadata=%s "
-          "send_trailing_metadata=%s",
-          LogTag().c_str(),
-          PollToString(
-              poll,
-              [](const ServerMetadataHandle& h) { return h->DebugString(); })
-              .c_str(),
-          send_initial_metadata_ == nullptr
-              ? "null"
-              : SendInitialMetadata::StateString(send_initial_metadata_->state),
-          StateString(send_trailing_state_));
+      LOG(INFO) << LogTag() << ": WakeInsideCombiner poll="
+                << PollToString(poll,
+                                [](const ServerMetadataHandle& h) {
+                                  return h->DebugString();
+                                })
+                       .c_str()
+                << "; send_initial_metadata="
+                << (send_initial_metadata_ == nullptr
+                        ? "null"
+                        : SendInitialMetadata::StateString(
+                              send_initial_metadata_->state))
+                << " send_trailing_metadata="
+                << StateString(send_trailing_state_);
     }
     if (send_initial_metadata_ != nullptr &&
         send_initial_metadata_->state ==
@@ -2501,12 +2476,12 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
       CHECK(send_initial_metadata_->metadata_next_.has_value());
       auto p = (*send_initial_metadata_->metadata_next_)();
       if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-        gpr_log(GPR_INFO,
-                "%s: WakeInsideCombiner send_initial_metadata poll=%s",
-                LogTag().c_str(),
-                PollToString(p, [](const NextResult<ServerMetadataHandle>& h) {
-                  return (*h)->DebugString();
-                }).c_str());
+        LOG(INFO) << LogTag()
+                  << ": WakeInsideCombiner send_initial_metadata poll="
+                  << PollToString(
+                         p, [](const NextResult<ServerMetadataHandle>& h) {
+                           return (*h)->DebugString();
+                         });
       }
       if (auto* nr = p.value_if_ready()) {
         ServerMetadataHandle md = std::move(nr->value());

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

@@ -150,16 +150,6 @@ class ChannelFilter {
   virtual bool GetChannelInfo(const grpc_channel_info*) { return false; }
 
   virtual ~ChannelFilter() = default;
-
-  grpc_event_engine::experimental::EventEngine*
-  hack_until_per_channel_stack_event_engines_land_get_event_engine() {
-    return event_engine_.get();
-  }
-
- private:
-  // TODO(ctiller): remove once per-channel-stack EventEngines land
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_ =
-      grpc_event_engine::experimental::GetDefaultEventEngine();
 };
 
 namespace promise_filter_detail {
@@ -953,9 +943,8 @@ class BaseCallData : public Activity, private Wakeable {
         : promise_detail::Context<Arena>(call_data->arena_),
           promise_detail::Context<grpc_polling_entity>(
               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_) {}
+          promise_detail::Context<CallFinalization>(&call_data->finalization_) {
+    }
   };
 
   class Flusher {
@@ -1305,7 +1294,6 @@ class BaseCallData : public Activity, private Wakeable {
   Pipe<ServerMetadataHandle>* const server_initial_metadata_pipe_;
   SendMessage* const send_message_;
   ReceiveMessage* const receive_message_;
-  grpc_event_engine::experimental::EventEngine* event_engine_;
 };
 
 class ClientCallData : public BaseCallData {
@@ -1659,7 +1647,7 @@ template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
 absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value &&
                       !std::is_base_of<ImplementChannelFilterTag, F>::value,
                   grpc_channel_filter>
-MakePromiseBasedFilter(const char* name) {
+MakePromiseBasedFilter() {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 
   return grpc_channel_filter{
@@ -1690,14 +1678,14 @@ MakePromiseBasedFilter(const char* name) {
       // get_channel_info
       promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
       // name
-      name,
+      UniqueTypeNameFor<F>(),
   };
 }
 
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
 absl::enable_if_t<std::is_base_of<ImplementChannelFilterTag, F>::value,
                   grpc_channel_filter>
-MakePromiseBasedFilter(const char* name) {
+MakePromiseBasedFilter() {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 
   return grpc_channel_filter{
@@ -1728,7 +1716,7 @@ MakePromiseBasedFilter(const char* name) {
       // get_channel_info
       promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
       // name
-      name,
+      UniqueTypeNameFor<F>(),
   };
 }
 

data/src/core/lib/compression/compression.cc

@@ -29,7 +29,6 @@
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/util/useful.h"
 
 int grpc_compression_algorithm_is_message(grpc_compression_algorithm) {
@@ -54,8 +53,9 @@ int grpc_compression_algorithm_parse(grpc_slice name,
 
 int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
                                     const char** name) {
-  GRPC_API_TRACE("grpc_compression_algorithm_name(algorithm=%d, name=%p)", 2,
-                 ((int)algorithm, name));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_compression_algorithm_name(algorithm=" << (int)algorithm
+      << ", name=" << name << ")";
   const char* result = grpc_core::CompressionAlgorithmAsString(algorithm);
   if (result != nullptr) {
     *name = result;