grpc 1.66.0 → 1.67.0.pre1

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

@@ -207,10 +207,8 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) {
     // refcnt==0 ==> cancelled
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      LOG(INFO) << releaser->call()->DebugTag()
-                << "RESUME BATCH REQUEST CANCELLED";
-    }
+    GRPC_TRACE_LOG(channel, INFO)
+        << releaser->call()->DebugTag() << "RESUME BATCH REQUEST CANCELLED";
     return;
   }
   if (--refcnt == 0) {
@@ -244,7 +242,10 @@ void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
 ///////////////////////////////////////////////////////////////////////////////
 // BaseCallData::Flusher
 
-BaseCallData::Flusher::Flusher(BaseCallData* call) : call_(call) {
+BaseCallData::Flusher::Flusher(BaseCallData* call)
+    : latent_see::InnerScope(
+          GRPC_LATENT_SEE_METADATA("PromiseBasedFilter Flusher")),
+      call_(call) {
   GRPC_CALL_STACK_REF(call_->call_stack(), "flusher");
 }
 
@@ -263,10 +264,9 @@ BaseCallData::Flusher::~Flusher() {
     auto* batch = static_cast<grpc_transport_stream_op_batch*>(p);
     BaseCallData* call =
         static_cast<BaseCallData*>(batch->handler_private.extra_arg);
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      LOG(INFO) << "FLUSHER:forward batch via closure: "
-                << grpc_transport_stream_op_batch_string(batch, false);
-    }
+    GRPC_TRACE_LOG(channel, 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");
   };
@@ -275,10 +275,9 @@ BaseCallData::Flusher::~Flusher() {
     if (call_->call() != nullptr && call_->call()->traced()) {
       batch->is_traced = true;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      LOG(INFO) << "FLUSHER:queue batch to forward in closure: "
-                << grpc_transport_stream_op_batch_string(release_[i], false);
-    }
+    GRPC_TRACE_LOG(channel, 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,
                       nullptr);
@@ -287,10 +286,9 @@ BaseCallData::Flusher::~Flusher() {
                        "flusher_batch");
   }
   call_closures_.RunClosuresWithoutYielding(call_->call_combiner());
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << "FLUSHER:forward batch: "
-              << grpc_transport_stream_op_batch_string(release_[0], false);
-  }
+  GRPC_TRACE_LOG(channel, 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;
   }
@@ -328,10 +326,8 @@ const char* BaseCallData::SendMessage::StateString(State state) {
 }
 
 void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " SendMessage.StartOp st=" << StateString(state_);
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag() << " SendMessage.StartOp st=" << StateString(state_);
   switch (state_) {
     case State::kInitial:
       state_ = State::kGotBatchNoPipe;
@@ -356,10 +352,8 @@ void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
 
 template <typename T>
 void BaseCallData::SendMessage::GotPipe(T* pipe_end) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " SendMessage.GotPipe st=" << StateString(state_);
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag() << " SendMessage.GotPipe st=" << StateString(state_);
   CHECK_NE(pipe_end, nullptr);
   switch (state_) {
     case State::kInitial:
@@ -404,11 +398,9 @@ bool BaseCallData::SendMessage::IsIdle() const {
 
 void BaseCallData::SendMessage::OnComplete(absl::Status status) {
   Flusher flusher(base_);
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " SendMessage.OnComplete st=" << StateString(state_)
-              << " status=" << status;
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag() << " SendMessage.OnComplete st=" << StateString(state_)
+      << " status=" << status;
   switch (state_) {
     case State::kInitial:
     case State::kIdle:
@@ -435,11 +427,9 @@ void BaseCallData::SendMessage::OnComplete(absl::Status status) {
 
 void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
                                      Flusher* flusher) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " SendMessage.Done st=" << StateString(state_)
-              << " md=" << metadata.DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag() << " SendMessage.Done st=" << StateString(state_)
+      << " md=" << metadata.DebugString();
   switch (state_) {
     case State::kCancelled:
     case State::kCancelledButNotYetPolled:
@@ -478,13 +468,12 @@ void BaseCallData::SendMessage::Done(const ServerMetadata& metadata,
 
 void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
                                                    bool allow_push_to_pipe) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " SendMessage.WakeInsideCombiner st=" << StateString(state_)
-              << (state_ == State::kBatchCompleted
-                      ? absl::StrCat(" status=", completed_status_.ToString())
-                      : "");
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag()
+      << " SendMessage.WakeInsideCombiner st=" << StateString(state_)
+      << (state_ == State::kBatchCompleted
+              ? absl::StrCat(" status=", completed_status_.ToString())
+              : "");
   switch (state_) {
     case State::kInitial:
     case State::kIdle:
@@ -512,12 +501,11 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       CHECK(push_.has_value());
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << base_->LogTag()
-                    << " SendMessage.WakeInsideCombiner push complete, "
-                       "result="
-                    << (*p ? "true" : "false");
-        }
+        GRPC_TRACE_LOG(channel, 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);
         state_ = State::kCancelled;
@@ -527,12 +515,11 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       CHECK(next_.has_value());
       auto r_next = (*next_)();
       if (auto* p = r_next.value_if_ready()) {
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << base_->LogTag()
-                    << " SendMessage.WakeInsideCombiner next complete, "
-                       "result.has_value="
-                    << (p->has_value() ? "true" : "false");
-        }
+        GRPC_TRACE_LOG(channel, 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());
           batch_->payload->send_message.flags = (**p)->flags();
@@ -612,10 +599,9 @@ const char* BaseCallData::ReceiveMessage::StateString(State state) {
 }
 
 void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " ReceiveMessage.StartOp st=" << StateString(state_);
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag()
+      << " ReceiveMessage.StartOp st=" << StateString(state_);
   switch (state_) {
     case State::kInitial:
       state_ = State::kForwardedBatchNoPipe;
@@ -653,10 +639,9 @@ void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
 
 template <typename T>
 void BaseCallData::ReceiveMessage::GotPipe(T* pipe_end) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " ReceiveMessage.GotPipe st=" << StateString(state_);
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag()
+      << " ReceiveMessage.GotPipe st=" << StateString(state_);
   switch (state_) {
     case State::kInitial:
       state_ = State::kIdle;
@@ -689,11 +674,10 @@ void BaseCallData::ReceiveMessage::GotPipe(T* pipe_end) {
 }
 
 void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " ReceiveMessage.OnComplete st=" << StateString(state_)
-              << " status=" << status;
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag()
+      << " ReceiveMessage.OnComplete st=" << StateString(state_)
+      << " status=" << status;
   switch (state_) {
     case State::kInitial:
     case State::kIdle:
@@ -730,11 +714,9 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
 
 void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
                                         Flusher* flusher) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << base_->LogTag()
-              << " ReceiveMessage.Done st=" << StateString(state_)
-              << " md=" << metadata.DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << base_->LogTag() << " ReceiveMessage.Done st=" << StateString(state_)
+      << " md=" << metadata.DebugString();
   switch (state_) {
     case State::kInitial:
       state_ = State::kCancelled;
@@ -789,13 +771,12 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
 
 void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
                                                       bool allow_push_to_pipe) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    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");
-  }
+  GRPC_TRACE_LOG(channel, 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:
     case State::kIdle:
@@ -850,11 +831,10 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       CHECK(push_.has_value());
       auto r_push = (*push_)();
       if (auto* p = r_push.value_if_ready()) {
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << base_->LogTag()
-                    << " ReceiveMessage.WakeInsideCombiner push complete: "
-                    << (*p ? "true" : "false");
-        }
+        GRPC_TRACE_LOG(channel, INFO)
+            << base_->LogTag()
+            << " ReceiveMessage.WakeInsideCombiner push complete: "
+            << (*p ? "true" : "false");
         // We haven't pulled through yet, so this certainly shouldn't succeed.
         CHECK(!*p);
         state_ = State::kCancelled;
@@ -881,12 +861,11 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
               p->cancelled() ? absl::CancelledError() : absl::OkStatus(),
               "recv_message");
         }
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << base_->LogTag()
-                    << " ReceiveMessage.WakeInsideCombiner next complete: "
-                    << (p->has_value() ? "got message" : "end of stream")
-                    << " new_state=" << StateString(state_);
-        }
+        GRPC_TRACE_LOG(channel, INFO)
+            << base_->LogTag()
+            << " ReceiveMessage.WakeInsideCombiner next complete: "
+            << (p->has_value() ? "got message" : "end of stream")
+            << " new_state=" << StateString(state_);
       }
       if (state_ != State::kPulledFromPipe &&
           state_ != State::kCompletedWhilePulledFromPipe) {
@@ -898,10 +877,9 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
     case State::kPulledFromPipe: {
       CHECK(push_.has_value());
       if ((*push_)().ready()) {
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << base_->LogTag()
-                    << " ReceiveMessage.WakeInsideCombiner push complete";
-        }
+        GRPC_TRACE_LOG(channel, INFO)
+            << base_->LogTag()
+            << " ReceiveMessage.WakeInsideCombiner push complete";
         if (state_ == State::kCompletedWhilePulledFromPipe) {
           interceptor()->Push()->Close();
           state_ = State::kCancelled;
@@ -1013,10 +991,9 @@ class ClientCallData::PollContext {
 
   void Run() {
     DCHECK(HasContext<Arena>());
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      LOG(INFO) << self_->LogTag() << " ClientCallData.PollContext.Run "
-                << self_->DebugString();
-    }
+    GRPC_TRACE_LOG(channel, INFO)
+        << self_->LogTag() << " ClientCallData.PollContext.Run "
+        << self_->DebugString();
     CHECK(have_scoped_activity_);
     repoll_ = false;
     if (self_->send_message() != nullptr) {
@@ -1097,15 +1074,14 @@ class ClientCallData::PollContext {
       case SendInitialState::kForwarded: {
         // Poll the promise once since we're waiting for it.
         Poll<ServerMetadataHandle> poll = self_->promise_();
-        if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-          LOG(INFO) << self_->LogTag()
-                    << " ClientCallData.PollContext.Run: poll="
-                    << PollToString(poll,
-                                    [](const ServerMetadataHandle& h) {
-                                      return h->DebugString();
-                                    })
-                    << "; " << self_->DebugString();
-        }
+        GRPC_TRACE_LOG(channel, 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);
           if (self_->send_message() != nullptr) {
@@ -1376,9 +1352,7 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   CapturedBatch batch(b);
   Flusher flusher(this);
 
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " StartBatch " << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO) << LogTag() << " StartBatch " << DebugString();
 
   // If this is a cancel stream, cancel anything we have pending and propagate
   // the cancellation.
@@ -1499,9 +1473,8 @@ 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)) {
-    LOG(INFO) << LogTag() << " Cancel error=" << error.ToString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << " Cancel error=" << error.ToString();
   // Track the latest reason for cancellation.
   cancelled_error_ = error;
   // Stop running the promise.
@@ -1578,11 +1551,10 @@ void ClientCallData::StartPromise(Flusher* flusher) {
 }
 
 void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " ClientCallData.RecvInitialMetadataReady "
-              << DebugString() << " error:" << error.ToString()
-              << " md:" << recv_initial_metadata_->metadata->DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << " ClientCallData.RecvInitialMetadataReady "
+      << DebugString() << " error:" << error.ToString()
+      << " md:" << recv_initial_metadata_->metadata->DebugString();
   ScopedContext context(this);
   Flusher flusher(this);
   if (!error.ok()) {
@@ -1661,10 +1633,8 @@ void ClientCallData::HookRecvTrailingMetadata(CapturedBatch batch) {
 //   - return a wrapper around PollTrailingMetadata as the promise.
 ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
     CallArgs call_args) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " ClientCallData.MakeNextPromise "
-              << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << " ClientCallData.MakeNextPromise " << DebugString();
   CHECK_NE(poll_ctx_, nullptr);
   CHECK(send_initial_state_ == SendInitialState::kQueued);
   send_initial_metadata_batch_->payload->send_initial_metadata
@@ -1724,10 +1694,8 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
 // All polls: await receiving the trailing metadata, then return it to the
 // application.
 Poll<ServerMetadataHandle> ClientCallData::PollTrailingMetadata() {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " ClientCallData.PollTrailingMetadata "
-              << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << " ClientCallData.PollTrailingMetadata " << DebugString();
   CHECK_NE(poll_ctx_, nullptr);
   if (send_initial_state_ == SendInitialState::kQueued) {
     // First poll: pass the send_initial_metadata op down the stack.
@@ -1775,12 +1743,10 @@ void ClientCallData::RecvTrailingMetadataReadyCallback(
 
 void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " ClientCallData.RecvTrailingMetadataReady "
-              << "recv_trailing_state=" << StateString(recv_trailing_state_)
-              << " error=" << error
-              << " md=" << recv_trailing_metadata_->DebugString();
-  }
+  GRPC_TRACE_LOG(channel, 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.
   if (recv_trailing_state_ == RecvTrailingState::kCancelled) {
@@ -1988,9 +1954,8 @@ ServerCallData::ServerCallData(grpc_call_element* elem,
 }
 
 ServerCallData::~ServerCallData() {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " ~ServerCallData " << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << " ~ServerCallData " << DebugString();
   if (send_initial_metadata_ != nullptr) {
     send_initial_metadata_->~SendInitialMetadata();
   }
@@ -2015,9 +1980,7 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
   Flusher flusher(this);
   bool wake = false;
 
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << " StartBatch: " << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO) << LogTag() << " StartBatch: " << DebugString();
 
   // If this is a cancel stream, cancel anything we have pending and
   // propagate the cancellation.
@@ -2148,15 +2111,13 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
 // Handle cancellation.
 void ServerCallData::Completed(grpc_error_handle error,
                                bool tarpit_cancellation, Flusher* flusher) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    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;
-  }
+  GRPC_TRACE_VLOG(channel, 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;
   // Stop running the promise.
@@ -2272,10 +2233,9 @@ ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
 // All polls: await sending the trailing metadata, then foward it down the
 // stack.
 Poll<ServerMetadataHandle> ServerCallData::PollTrailingMetadata() {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag()
-              << " PollTrailingMetadata: " << StateString(send_trailing_state_);
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag()
+      << " PollTrailingMetadata: " << StateString(send_trailing_state_);
   switch (send_trailing_state_) {
     case SendTrailingState::kInitial:
     case SendTrailingState::kQueuedBehindSendMessage:
@@ -2303,10 +2263,9 @@ void ServerCallData::RecvTrailingMetadataReadyCallback(
 }
 
 void ServerCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << ": RecvTrailingMetadataReady error=" << error
-              << " md=" << recv_trailing_metadata_->DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << ": RecvTrailingMetadataReady error=" << error
+      << " md=" << recv_trailing_metadata_->DebugString();
   Flusher flusher(this);
   PollContext poll_ctx(this, &flusher);
   Completed(error, recv_trailing_metadata_->get(GrpcTarPit()).has_value(),
@@ -2322,9 +2281,8 @@ void ServerCallData::RecvInitialMetadataReadyCallback(void* arg,
 
 void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << ": RecvInitialMetadataReady " << error;
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << ": RecvInitialMetadataReady " << error;
   CHECK(recv_initial_state_ == RecvInitialState::kForwarded);
   // If there was an error we just propagate that through
   if (!error.ok()) {
@@ -2386,9 +2344,8 @@ std::string ServerCallData::DebugString() const {
 // Wakeup and poll the promise if appropriate.
 void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
   PollContext poll_ctx(this, flusher);
-  if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << LogTag() << ": WakeInsideCombiner " << DebugString();
-  }
+  GRPC_TRACE_LOG(channel, INFO)
+      << LogTag() << ": WakeInsideCombiner " << DebugString();
   poll_ctx.ClearRepoll();
   if (send_initial_metadata_ != nullptr) {
     if (send_initial_metadata_->state ==
@@ -2408,12 +2365,12 @@ 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)) {
-          LOG(INFO) << LogTag() << ": WakeInsideCombiner: metadata_push done";
-        }
+        GRPC_TRACE_LOG(channel, INFO)
+            << LogTag() << ": WakeInsideCombiner: metadata_push done";
         send_initial_metadata_->metadata_push_.reset();
-      } else if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-        LOG(INFO) << LogTag() << ": WakeInsideCombiner: metadata_push pending";
+      } else {
+        GRPC_TRACE_LOG(channel, INFO)
+            << LogTag() << ": WakeInsideCombiner: metadata_push pending";
       }
     }
   }
@@ -2429,11 +2386,10 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
         flusher,
         send_initial_metadata_ == nullptr ||
             send_initial_metadata_->state == SendInitialMetadata::kForwarded);
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      VLOG(2) << LogTag() << ": After send_message WakeInsideCombiner "
-              << DebugString() << " is_idle=" << send_message()->IsIdle()
-              << " is_forwarded=" << send_message()->IsForwarded();
-    }
+    GRPC_TRACE_VLOG(channel, 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() ||
          (send_trailing_metadata_batch_->send_message &&
@@ -2455,34 +2411,30 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
   if (promise_.has_value()) {
     Poll<ServerMetadataHandle> poll;
     poll = promise_();
-    if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-      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_);
-    }
+    GRPC_TRACE_LOG(channel, 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 ==
             SendInitialMetadata::kQueuedAndPushedToPipe) {
       CHECK(send_initial_metadata_->metadata_next_.has_value());
       auto p = (*send_initial_metadata_->metadata_next_)();
-      if (GRPC_TRACE_FLAG_ENABLED(channel)) {
-        LOG(INFO) << LogTag()
-                  << ": WakeInsideCombiner send_initial_metadata poll="
-                  << PollToString(
-                         p, [](const NextResult<ServerMetadataHandle>& h) {
-                           return (*h)->DebugString();
-                         });
-      }
+      GRPC_TRACE_LOG(channel, 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());
         if (send_initial_metadata_->batch->payload->send_initial_metadata

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

@@ -947,7 +947,7 @@ class BaseCallData : public Activity, private Wakeable {
     }
   };
 
-  class Flusher {
+  class Flusher : public latent_see::InnerScope {
    public:
     explicit Flusher(BaseCallData* call);
     // Calls closures, schedules batches, relinquishes call combiner.

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

@@ -29,7 +29,6 @@
 #include "absl/strings/str_split.h"
 
 #include <grpc/compression.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/config/config_vars.cc

@@ -72,6 +72,10 @@ ABSL_FLAG(absl::optional<bool>, grpc_not_use_system_ssl_roots, {},
           "Disable loading system root certificates.");
 ABSL_FLAG(absl::optional<std::string>, grpc_ssl_cipher_suites, {},
           "A colon separated list of cipher suites to use with OpenSSL");
+ABSL_FLAG(absl::optional<bool>, grpc_cpp_experimental_disable_reflection, {},
+          "EXPERIMENTAL. Only respected when there is a dependency on "
+          ":grpc++_reflection. If true, no reflection server will be "
+          "automatically added.");
 
 namespace grpc_core {
 
@@ -89,6 +93,10 @@ ConfigVars::ConfigVars(const Overrides& overrides)
       not_use_system_ssl_roots_(LoadConfig(
           FLAGS_grpc_not_use_system_ssl_roots, "GRPC_NOT_USE_SYSTEM_SSL_ROOTS",
           overrides.not_use_system_ssl_roots, false)),
+      cpp_experimental_disable_reflection_(
+          LoadConfig(FLAGS_grpc_cpp_experimental_disable_reflection,
+                     "GRPC_CPP_EXPERIMENTAL_DISABLE_REFLECTION",
+                     overrides.cpp_experimental_disable_reflection, false)),
       dns_resolver_(LoadConfig(FLAGS_grpc_dns_resolver, "GRPC_DNS_RESOLVER",
                                overrides.dns_resolver, "")),
       verbosity_(LoadConfig(FLAGS_grpc_verbosity, "GRPC_VERBOSITY",
@@ -136,7 +144,9 @@ std::string ConfigVars::ToString() const {
       "\"", ", default_ssl_roots_file_path: ", "\"",
       absl::CEscape(DefaultSslRootsFilePath()), "\"",
       ", not_use_system_ssl_roots: ", NotUseSystemSslRoots() ? "true" : "false",
-      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"");
+      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"",
+      ", cpp_experimental_disable_reflection: ",
+      CppExperimentalDisableReflection() ? "true" : "false");
 }
 
 }  // namespace grpc_core