grpc 1.66.0 → 1.67.0.pre1

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -139,21 +139,18 @@ RetryFilter::LegacyCallData::CallAttempt::CallAttempt(
         }
       },
       is_transparent_retry);
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << this
-              << ": created attempt, lb_call=" << lb_call_.get();
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld << " attempt=" << this
+      << ": created attempt, lb_call=" << lb_call_.get();
   // If per_attempt_recv_timeout is set, start a timer.
   if (calld->retry_policy_ != nullptr &&
       calld->retry_policy_->per_attempt_recv_timeout().has_value()) {
     const Duration per_attempt_recv_timeout =
         *calld->retry_policy_->per_attempt_recv_timeout();
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-                << " attempt=" << this << ": per-attempt timeout in "
-                << per_attempt_recv_timeout.millis() << " ms";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld->chand_ << " calld=" << calld
+        << " attempt=" << this << ": per-attempt timeout in "
+        << per_attempt_recv_timeout.millis() << " ms";
     // Schedule retry after computed delay.
     GRPC_CALL_STACK_REF(calld->owning_call_, "OnPerAttemptRecvTimer");
     Ref(DEBUG_LOCATION, "OnPerAttemptRecvTimer").release();
@@ -167,10 +164,9 @@ RetryFilter::LegacyCallData::CallAttempt::CallAttempt(
 }
 
 RetryFilter::LegacyCallData::CallAttempt::~CallAttempt() {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this << ": destroying call attempt";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this << ": destroying call attempt";
 }
 
 void RetryFilter::LegacyCallData::CallAttempt::
@@ -234,12 +230,11 @@ void RetryFilter::LegacyCallData::CallAttempt::MaybeSwitchToFastPath() {
   // yet seen that op from the surface, we can't switch yet.
   if (recv_trailing_metadata_internal_batch_ != nullptr) return;
   // Switch to fast path.
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this
-              << ": retry state no longer needed; "
-                 "moving LB call to parent and unreffing the call attempt";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this
+      << ": retry state no longer needed; "
+         "moving LB call to parent and unreffing the call attempt";
   calld_->committed_call_ = std::move(lb_call_);
   calld_->call_attempt_.reset(DEBUG_LOCATION, "MaybeSwitchToFastPath");
 }
@@ -253,12 +248,10 @@ RetryFilter::LegacyCallData::CallAttempt::MaybeCreateBatchForReplay() {
   // send_initial_metadata.
   if (calld_->seen_send_initial_metadata_ && !started_send_initial_metadata_ &&
       !calld_->pending_send_initial_metadata_) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this
-                << ": replaying previously completed "
-                   "send_initial_metadata op";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << calld_->chand_
+                                << " calld=" << calld_ << " attempt=" << this
+                                << ": replaying previously completed "
+                                   "send_initial_metadata op";
     replay_batch_data = CreateBatch(1, true /* set_on_complete */);
     replay_batch_data->AddRetriableSendInitialMetadataOp();
   }
@@ -267,12 +260,10 @@ RetryFilter::LegacyCallData::CallAttempt::MaybeCreateBatchForReplay() {
   if (started_send_message_count_ < calld_->send_messages_.size() &&
       started_send_message_count_ == completed_send_message_count_ &&
       !calld_->pending_send_message_) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this
-                << ": replaying previously completed "
-                   "send_message op";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << calld_->chand_
+                                << " calld=" << calld_ << " attempt=" << this
+                                << ": replaying previously completed "
+                                   "send_message op";
     if (replay_batch_data == nullptr) {
       replay_batch_data = CreateBatch(1, true /* set_on_complete */);
     }
@@ -286,12 +277,10 @@ RetryFilter::LegacyCallData::CallAttempt::MaybeCreateBatchForReplay() {
       started_send_message_count_ == calld_->send_messages_.size() &&
       !started_send_trailing_metadata_ &&
       !calld_->pending_send_trailing_metadata_) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this
-                << ": replaying previously completed "
-                   "send_trailing_metadata op";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << calld_->chand_
+                                << " calld=" << calld_ << " attempt=" << this
+                                << ": replaying previously completed "
+                                   "send_trailing_metadata op";
     if (replay_batch_data == nullptr) {
       replay_batch_data = CreateBatch(1, true /* set_on_complete */);
     }
@@ -317,11 +306,10 @@ void StartBatchInCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
 void RetryFilter::LegacyCallData::CallAttempt::AddClosureForBatch(
     grpc_transport_stream_op_batch* batch, const char* reason,
     CallCombinerClosureList* closures) {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this << ": adding batch (" << reason
-              << "): " << grpc_transport_stream_op_batch_string(batch, false);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this << ": adding batch (" << reason
+      << "): " << grpc_transport_stream_op_batch_string(batch, false);
   batch->handler_private.extra_arg = lb_call_.get();
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, StartBatchInCallCombiner,
                     batch, grpc_schedule_on_exec_ctx);
@@ -330,12 +318,11 @@ void RetryFilter::LegacyCallData::CallAttempt::AddClosureForBatch(
 
 void RetryFilter::LegacyCallData::CallAttempt::
     AddBatchForInternalRecvTrailingMetadata(CallCombinerClosureList* closures) {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this
-              << ": call failed but recv_trailing_metadata not started; "
-                 "starting it internally";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this
+      << ": call failed but recv_trailing_metadata not started; "
+         "starting it internally";
   // Create batch_data with 2 refs, since this batch will be unreffed twice:
   // once for the recv_trailing_metadata_ready callback when the batch
   // completes, and again when we actually get a recv_trailing_metadata
@@ -520,20 +507,18 @@ void RetryFilter::LegacyCallData::CallAttempt::AddRetriableBatches(
 }
 
 void RetryFilter::LegacyCallData::CallAttempt::StartRetriableBatches() {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this << ": constructing retriable batches";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this << ": constructing retriable batches";
   // Construct list of closures to execute, one for each pending batch.
   CallCombinerClosureList closures;
   AddRetriableBatches(&closures);
   // Note: This will yield the call combiner.
   // Start batches on LB call.
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-              << " attempt=" << this << ": starting " << closures.size()
-              << " retriable batches on lb_call=" << lb_call_.get();
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld_->chand_ << " calld=" << calld_
+      << " attempt=" << this << ": starting " << closures.size()
+      << " retriable batches on lb_call=" << lb_call_.get();
   closures.RunClosures(calld_->call_combiner_);
 }
 
@@ -556,20 +541,18 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
       if (calld_->retry_throttle_data_ != nullptr) {
         calld_->retry_throttle_data_->RecordSuccess();
       }
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                  << " attempt=" << this << ": call succeeded";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld_->chand_ << " calld=" << calld_
+          << " attempt=" << this << ": call succeeded";
       return false;
     }
     // Status is not OK.  Check whether the status is retryable.
     if (!calld_->retry_policy_->retryable_status_codes().Contains(*status)) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                  << " attempt=" << this << ": status "
-                  << grpc_status_code_to_string(*status)
-                  << " not configured as retryable";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld_->chand_ << " calld=" << calld_
+          << " attempt=" << this << ": status "
+          << grpc_status_code_to_string(*status)
+          << " not configured as retryable";
       return false;
     }
   }
@@ -582,46 +565,40 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
   // checks, so that we don't fail to record failures due to other factors.
   if (calld_->retry_throttle_data_ != nullptr &&
       !calld_->retry_throttle_data_->RecordFailure()) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this << ": retries throttled";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld_->chand_ << " calld=" << calld_
+        << " attempt=" << this << ": retries throttled";
     return false;
   }
   // Check whether the call is committed.
   if (calld_->retry_committed_) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this << ": retries already committed";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld_->chand_ << " calld=" << calld_
+        << " attempt=" << this << ": retries already committed";
     return false;
   }
   // Check whether we have retries remaining.
   ++calld_->num_attempts_completed_;
   if (calld_->num_attempts_completed_ >=
       calld_->retry_policy_->max_attempts()) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this << ": exceeded "
-                << calld_->retry_policy_->max_attempts() << " retry attempts";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld_->chand_ << " calld=" << calld_
+        << " attempt=" << this << ": exceeded "
+        << calld_->retry_policy_->max_attempts() << " retry attempts";
     return false;
   }
   // Check server push-back.
   if (server_pushback.has_value()) {
     if (*server_pushback < Duration::Zero()) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                  << " attempt=" << this
-                  << ": not retrying due to server push-back";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld_->chand_ << " calld=" << calld_
+          << " attempt=" << this << ": not retrying due to server push-back";
       return false;
     } else {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                  << " attempt=" << this << ": server push-back: retry in "
-                  << server_pushback->millis() << " ms";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld_->chand_ << " calld=" << calld_
+          << " attempt=" << this << ": server push-back: retry in "
+          << server_pushback->millis() << " ms";
     }
   }
   // We should retry.
@@ -665,14 +642,12 @@ void RetryFilter::LegacyCallData::CallAttempt::OnPerAttemptRecvTimerLocked(
     void* arg, grpc_error_handle error) {
   auto* call_attempt = static_cast<CallAttempt*>(arg);
   auto* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << ": perAttemptRecvTimeout timer fired: error="
-              << StatusToString(error)
-              << ", per_attempt_recv_timer_handle_.has_value()="
-              << call_attempt->per_attempt_recv_timer_handle_.has_value();
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt
+      << ": perAttemptRecvTimeout timer fired: error=" << StatusToString(error)
+      << ", per_attempt_recv_timer_handle_.has_value()="
+      << call_attempt->per_attempt_recv_timer_handle_.has_value();
   CallCombinerClosureList closures;
   call_attempt->per_attempt_recv_timer_handle_.reset();
   // Cancel this attempt.
@@ -705,11 +680,9 @@ void RetryFilter::LegacyCallData::CallAttempt::OnPerAttemptRecvTimerLocked(
 void RetryFilter::LegacyCallData::CallAttempt::
     MaybeCancelPerAttemptRecvTimer() {
   if (per_attempt_recv_timer_handle_.has_value()) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld_->chand_ << " calld=" << calld_
-                << " attempt=" << this
-                << ": cancelling perAttemptRecvTimeout timer";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld_->chand_ << " calld=" << calld_
+        << " attempt=" << this << ": cancelling perAttemptRecvTimeout timer";
     if (calld_->chand_->event_engine()->Cancel(
             *per_attempt_recv_timer_handle_)) {
       Unref(DEBUG_LOCATION, "OnPerAttemptRecvTimer");
@@ -728,11 +701,10 @@ RetryFilter::LegacyCallData::CallAttempt::BatchData::BatchData(
     : RefCounted(GRPC_TRACE_FLAG_ENABLED(retry) ? "BatchData" : nullptr,
                  refcount),
       call_attempt_(attempt.release()) {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << call_attempt_->calld_->chand_
-              << " calld=" << call_attempt_->calld_
-              << " attempt=" << call_attempt_ << ": creating batch " << this;
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << call_attempt_->calld_->chand_
+      << " calld=" << call_attempt_->calld_ << " attempt=" << call_attempt_
+      << ": creating batch " << this;
   // We hold a ref to the call stack for every batch sent on a call attempt.
   // This is because some batches on the call attempt may not complete
   // until after all of the batches are completed at the surface (because
@@ -749,11 +721,10 @@ RetryFilter::LegacyCallData::CallAttempt::BatchData::BatchData(
 }
 
 RetryFilter::LegacyCallData::CallAttempt::BatchData::~BatchData() {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << call_attempt_->calld_->chand_
-              << " calld=" << call_attempt_->calld_
-              << " attempt=" << call_attempt_ << ": destroying batch " << this;
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << call_attempt_->calld_->chand_
+      << " calld=" << call_attempt_->calld_ << " attempt=" << call_attempt_
+      << ": destroying batch " << this;
   CallAttempt* call_attempt = std::exchange(call_attempt_, nullptr);
   grpc_call_stack* owning_call = call_attempt->calld_->owning_call_;
   call_attempt->Unref(DEBUG_LOCATION, "~BatchData");
@@ -822,13 +793,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
   CallAttempt* call_attempt = batch_data->call_attempt_;
   RetryFilter::LegacyCallData* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << " batch_data=" << batch_data.get()
-              << ": got recv_initial_metadata_ready, error="
-              << StatusToString(error);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt << " batch_data=" << batch_data.get()
+      << ": got recv_initial_metadata_ready, error=" << StatusToString(error);
   call_attempt->completed_recv_initial_metadata_ = true;
   // If this attempt has been abandoned, then we're not going to use the
   // result of this recv_initial_metadata op, so do nothing.
@@ -849,11 +817,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
     if (GPR_UNLIKELY(
             (call_attempt->trailing_metadata_available_ || !error.ok()) &&
             !call_attempt->completed_recv_trailing_metadata_)) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-                  << " attempt=" << call_attempt
-                  << ": deferring recv_initial_metadata_ready (Trailers-Only)";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld->chand_ << " calld=" << calld
+          << " attempt=" << call_attempt
+          << ": deferring recv_initial_metadata_ready (Trailers-Only)";
       call_attempt->recv_initial_metadata_ready_deferred_batch_ =
           std::move(batch_data);
       call_attempt->recv_initial_metadata_error_ = error;
@@ -920,12 +887,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::RecvMessageReady(
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
   CallAttempt* call_attempt = batch_data->call_attempt_;
   RetryFilter::LegacyCallData* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << " batch_data=" << batch_data.get()
-              << ": got recv_message_ready, error=" << StatusToString(error);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt << " batch_data=" << batch_data.get()
+      << ": got recv_message_ready, error=" << StatusToString(error);
   ++call_attempt->completed_recv_message_count_;
   // If this attempt has been abandoned, then we're not going to use the
   // result of this recv_message op, so do nothing.
@@ -949,12 +914,11 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::RecvMessageReady(
     if (GPR_UNLIKELY(
             (!call_attempt->recv_message_.has_value() || !error.ok()) &&
             !call_attempt->completed_recv_trailing_metadata_)) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-                  << " attempt=" << call_attempt
-                  << ": deferring recv_message_ready (nullptr message and "
-                     "recv_trailing_metadata pending)";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << calld->chand_ << " calld=" << calld
+          << " attempt=" << call_attempt
+          << ": deferring recv_message_ready (nullptr message and "
+             "recv_trailing_metadata pending)";
       call_attempt->recv_message_ready_deferred_batch_ = std::move(batch_data);
       call_attempt->recv_message_error_ = error;
       CallCombinerClosureList closures;
@@ -1113,13 +1077,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
   CallAttempt* call_attempt = batch_data->call_attempt_;
   RetryFilter::LegacyCallData* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << " batch_data=" << batch_data.get()
-              << ": got recv_trailing_metadata_ready, error="
-              << StatusToString(error);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt << " batch_data=" << batch_data.get()
+      << ": got recv_trailing_metadata_ready, error=" << StatusToString(error);
   call_attempt->completed_recv_trailing_metadata_ = true;
   // If this attempt has been abandoned, then we're not going to use the
   // result of this recv_trailing_metadata op, so do nothing.
@@ -1140,17 +1101,15 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
       batch_data->batch_.payload->recv_trailing_metadata.recv_trailing_metadata;
   GetCallStatus(calld->deadline_, md_batch, error, &status, &server_pushback,
                 &is_lb_drop, &stream_network_state);
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt << ": call finished, status="
-              << grpc_status_code_to_string(status) << " server_pushback="
-              << (server_pushback.has_value() ? server_pushback->ToString()
-                                              : "N/A")
-              << " is_lb_drop=" << is_lb_drop << " stream_network_state="
-              << (stream_network_state.has_value()
-                      ? absl::StrCat(*stream_network_state)
-                      : "N/A");
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt
+      << ": call finished, status=" << grpc_status_code_to_string(status)
+      << " server_pushback="
+      << (server_pushback.has_value() ? server_pushback->ToString() : "N/A")
+      << " is_lb_drop=" << is_lb_drop << " stream_network_state="
+      << (stream_network_state.has_value() ? absl::StrCat(*stream_network_state)
+                                           : "N/A");
   // Check if we should retry.
   if (!is_lb_drop) {  // Never retry on LB drops.
     enum { kNoRetry, kTransparentRetry, kConfigurableRetry } retry = kNoRetry;
@@ -1259,11 +1218,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
     }
   }
   if (have_pending_send_ops) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-                << " attempt=" << call_attempt_
-                << ": starting next batch for pending send op(s)";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld->chand_ << " calld=" << calld
+        << " attempt=" << call_attempt_
+        << ": starting next batch for pending send op(s)";
     call_attempt_->AddRetriableBatches(closures);
   }
 }
@@ -1273,15 +1231,11 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::OnComplete(
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
   CallAttempt* call_attempt = batch_data->call_attempt_;
   RetryFilter::LegacyCallData* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << " batch_data=" << batch_data.get()
-              << ": got on_complete, error=" << StatusToString(error)
-              << ", batch="
-              << grpc_transport_stream_op_batch_string(&batch_data->batch_,
-                                                       false);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt << " batch_data=" << batch_data.get()
+      << ": got on_complete, error=" << StatusToString(error) << ", batch="
+      << grpc_transport_stream_op_batch_string(&batch_data->batch_, false);
   // If this attempt has been abandoned, then we're not going to propagate
   // the completion of this batch, so do nothing.
   if (call_attempt->abandoned_) {
@@ -1295,10 +1249,9 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::OnComplete(
   // recv_trailing_metadata comes back.
   if (GPR_UNLIKELY(!calld->retry_committed_ && !error.ok() &&
                    !call_attempt->completed_recv_trailing_metadata_)) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-                << " attempt=" << call_attempt << ": deferring on_complete";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << calld->chand_ << " calld=" << calld
+        << " attempt=" << call_attempt << ": deferring on_complete";
     call_attempt->on_complete_deferred_batches_.emplace_back(
         std::move(batch_data), error);
     CallCombinerClosureList closures;
@@ -1349,15 +1302,12 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::OnCompleteForCancelOp(
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
   CallAttempt* call_attempt = batch_data->call_attempt_;
   RetryFilter::LegacyCallData* calld = call_attempt->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt
-              << " batch_data=" << batch_data.get()
-              << ": got on_complete for cancel_stream batch, error="
-              << StatusToString(error) << ", batch="
-              << grpc_transport_stream_op_batch_string(&batch_data->batch_,
-                                                       false);
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt << " batch_data=" << batch_data.get()
+      << ": got on_complete for cancel_stream batch, error="
+      << StatusToString(error) << ", batch="
+      << grpc_transport_stream_op_batch_string(&batch_data->batch_, false);
   GRPC_CALL_COMBINER_STOP(
       calld->call_combiner_,
       "on_complete for internally generated cancel_stream op");
@@ -1392,12 +1342,10 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
 void RetryFilter::LegacyCallData::CallAttempt::BatchData::
     AddRetriableSendMessageOp() {
   auto* calld = call_attempt_->calld_;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << calld->chand_ << " calld=" << calld
-              << " attempt=" << call_attempt_
-              << ": starting calld->send_messages["
-              << call_attempt_->started_send_message_count_ << "]";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << calld->chand_ << " calld=" << calld
+      << " attempt=" << call_attempt_ << ": starting calld->send_messages["
+      << call_attempt_->started_send_message_count_ << "]";
   CachedSendMessage cache =
       calld->send_messages_[call_attempt_->started_send_message_count_];
   ++call_attempt_->started_send_message_count_;
@@ -1479,10 +1427,8 @@ grpc_error_handle RetryFilter::LegacyCallData::Init(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   auto* chand = static_cast<RetryFilter*>(elem->channel_data);
   new (elem->call_data) RetryFilter::LegacyCallData(chand, *args);
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand << " calld=" << elem->call_data
-              << ": created call";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << chand << " calld=" << elem->call_data << ": created call";
   return absl::OkStatus();
 }
 
@@ -1584,11 +1530,9 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
   if (GPR_UNLIKELY(batch->cancel_stream)) {
     // Save cancel_error in case subsequent batches are started.
     cancelled_from_surface_ = batch->payload->cancel_stream.cancel_error;
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                << ": cancelled from surface: "
-                << StatusToString(cancelled_from_surface_);
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                                << ": cancelled from surface: "
+                                << StatusToString(cancelled_from_surface_);
     // Fail any pending batches.
     PendingBatchesFail(cancelled_from_surface_);
     // If we have a current call attempt, commit the call, then send
@@ -1608,10 +1552,8 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
     }
     // Cancel retry timer if needed.
     if (retry_timer_handle_.has_value()) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                  << ": cancelling retry timer";
-      }
+      GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                                  << ": cancelling retry timer";
       if (chand_->event_engine()->Cancel(*retry_timer_handle_)) {
         GRPC_CALL_STACK_UNREF(owning_call_, "OnRetryTimer");
       }
@@ -1654,11 +1596,9 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
     if (!retry_codepath_started_ && retry_committed_ &&
         (retry_policy_ == nullptr ||
          !retry_policy_->per_attempt_recv_timeout().has_value())) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                  << ": retry committed before first attempt; "
-                  << "creating LB call";
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << chand_ << " calld=" << this
+          << ": retry committed before first attempt; creating LB call";
       PendingBatchClear(pending);
       auto* service_config_call_data =
           DownCast<ClientChannelServiceConfigCallData*>(
@@ -1672,19 +1612,16 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
     // Otherwise, create a call attempt.
     // The attempt will automatically start any necessary replays or
     // pending batches.
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                << ": creating call attempt";
-    }
+    GRPC_TRACE_LOG(retry, INFO)
+        << "chand=" << chand_ << " calld=" << this << ": creating call attempt";
     retry_codepath_started_ = true;
     CreateCallAttempt(/*is_transparent_retry=*/false);
     return;
   }
   // Send batches to call attempt.
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": starting batch on attempt=" << call_attempt_.get();
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << chand_ << " calld=" << this
+      << ": starting batch on attempt=" << call_attempt_.get();
   call_attempt_->StartRetriableBatches();
 }
 
@@ -1739,28 +1676,22 @@ void RetryFilter::LegacyCallData::MaybeCacheSendOpsForBatch(
 }
 
 void RetryFilter::LegacyCallData::FreeCachedSendInitialMetadata() {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": destroying send_initial_metadata";
-  }
+  GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                              << ": destroying send_initial_metadata";
   send_initial_metadata_.Clear();
 }
 
 void RetryFilter::LegacyCallData::FreeCachedSendMessage(size_t idx) {
   if (send_messages_[idx].slices != nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                << ": destroying send_messages[" << idx << "]";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                                << ": destroying send_messages[" << idx << "]";
     Destruct(std::exchange(send_messages_[idx].slices, nullptr));
   }
 }
 
 void RetryFilter::LegacyCallData::FreeCachedSendTrailingMetadata() {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": destroying send_trailing_metadata";
-  }
+  GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                              << ": destroying send_trailing_metadata";
   send_trailing_metadata_.Clear();
 }
 
@@ -1796,10 +1727,8 @@ RetryFilter::LegacyCallData::PendingBatch*
 RetryFilter::LegacyCallData::PendingBatchesAdd(
     grpc_transport_stream_op_batch* batch) {
   const size_t idx = GetBatchIndex(batch);
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": adding pending batch at index " << idx;
-  }
+  GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                              << ": adding pending batch at index " << idx;
   PendingBatch* pending = &pending_batches_[idx];
   CHECK_EQ(pending->batch, nullptr);
   pending->batch = batch;
@@ -1826,10 +1755,8 @@ RetryFilter::LegacyCallData::PendingBatchesAdd(
   // ops have already been sent, and we commit to that attempt.
   if (GPR_UNLIKELY(bytes_buffered_for_retry_ >
                    chand_->per_rpc_retry_buffer_size())) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                << ": exceeded retry buffer size, committing";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                                << ": exceeded retry buffer size, committing";
     RetryCommit(call_attempt_.get());
   }
   return pending;
@@ -1862,10 +1789,8 @@ void RetryFilter::LegacyCallData::MaybeClearPendingBatch(
       (!batch->recv_trailing_metadata ||
        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready ==
            nullptr)) {
-    if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-      LOG(INFO) << "chand=" << chand_ << " calld=" << this
-                << ": clearing pending batch";
-    }
+    GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                                << ": clearing pending batch";
     PendingBatchClear(pending);
   }
 }
@@ -1918,10 +1843,9 @@ RetryFilter::LegacyCallData::PendingBatchFind(const char* log_message,
     PendingBatch* pending = &pending_batches_[i];
     grpc_transport_stream_op_batch* batch = pending->batch;
     if (batch != nullptr && predicate(batch)) {
-      if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-        LOG(INFO) << "chand=" << chand_ << " calld=" << this << ": "
-                  << log_message << " pending batch at index " << i;
-      }
+      GRPC_TRACE_LOG(retry, INFO)
+          << "chand=" << chand_ << " calld=" << this << ": " << log_message
+          << " pending batch at index " << i;
       return pending;
     }
   }
@@ -1935,10 +1859,8 @@ RetryFilter::LegacyCallData::PendingBatchFind(const char* log_message,
 void RetryFilter::LegacyCallData::RetryCommit(CallAttempt* call_attempt) {
   if (retry_committed_) return;
   retry_committed_ = true;
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": committing retries";
-  }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << chand_ << " calld=" << this << ": committing retries";
   if (call_attempt != nullptr) {
     // If the call attempt's LB call has been committed, invoke the
     // call's on_commit callback.
@@ -1968,13 +1890,11 @@ void RetryFilter::LegacyCallData::StartRetryTimer(
     next_attempt_timeout = *server_pushback;
     retry_backoff_.Reset();
   } else {
-    next_attempt_timeout = retry_backoff_.NextAttemptTime() - Timestamp::Now();
-  }
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": retrying failed call in " << next_attempt_timeout.millis()
-              << " ms";
+    next_attempt_timeout = retry_backoff_.NextAttemptDelay();
   }
+  GRPC_TRACE_LOG(retry, INFO)
+      << "chand=" << chand_ << " calld=" << this << ": retrying failed call in "
+      << next_attempt_timeout.millis() << " ms";
   // Schedule retry after computed delay.
   GRPC_CALL_STACK_REF(owning_call_, "OnRetryTimer");
   retry_timer_handle_ =
@@ -2003,10 +1923,8 @@ void RetryFilter::LegacyCallData::OnRetryTimerLocked(
 
 void RetryFilter::LegacyCallData::AddClosureToStartTransparentRetry(
     CallCombinerClosureList* closures) {
-  if (GRPC_TRACE_FLAG_ENABLED(retry)) {
-    LOG(INFO) << "chand=" << chand_ << " calld=" << this
-              << ": scheduling transparent retry";
-  }
+  GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
+                              << ": scheduling transparent retry";
   GRPC_CALL_STACK_REF(owning_call_, "OnRetryTimer");
   GRPC_CLOSURE_INIT(&retry_closure_, StartTransparentRetry, this, nullptr);
   closures->Add(&retry_closure_, absl::OkStatus(), "start transparent retry");