grpc 1.66.0 → 1.67.0.pre1

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -851,14 +851,12 @@ void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
       parent()->lb_calld_->client_stats() != nullptr) {
     client_stats = parent()->lb_calld_->client_stats()->Ref();
   }
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    GRPC_TRACE_LOG(glb, INFO)
-        << "[grpclb " << parent() << " helper " << this
-        << "] state=" << ConnectivityStateName(state) << " ("
-        << status.ToString() << ") wrapping child picker " << picker.get()
-        << " (serverlist=" << serverlist.get()
-        << ", client_stats=" << client_stats.get() << ")";
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << parent() << " helper " << this
+      << "] state=" << ConnectivityStateName(state) << " (" << status.ToString()
+      << ") wrapping child picker " << picker.get()
+      << " (serverlist=" << serverlist.get()
+      << ", client_stats=" << client_stats.get() << ")";
   parent()->channel_control_helper()->UpdateState(
       state, status,
       MakeRefCounted<Picker>(std::move(serverlist), std::move(picker),
@@ -948,10 +946,9 @@ void GrpcLb::BalancerCallState::Orphan() {
 
 void GrpcLb::BalancerCallState::StartQuery() {
   CHECK_NE(lb_call_, nullptr);
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << grpclb_policy_.get() << "] lb_calld=" << this
-              << ": Starting LB call " << lb_call_;
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << grpclb_policy_.get() << "] lb_calld=" << this
+      << ": Starting LB call " << lb_call_;
   // Create the ops.
   grpc_call_error call_error;
   grpc_op ops[3];
@@ -1175,17 +1172,16 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
         if (response.client_stats_report_interval != Duration::Zero()) {
           client_stats_report_interval_ = std::max(
               Duration::Seconds(1), response.client_stats_report_interval);
-          if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-            LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-                      << ": Received initial LB response message; client load "
-                         "reporting interval = "
-                      << client_stats_report_interval_.millis()
-                      << " milliseconds";
-          }
-        } else if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-          LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-                    << ": Received initial LB response message; client load "
-                       "reporting NOT enabled";
+          GRPC_TRACE_LOG(glb, INFO)
+              << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+              << ": Received initial LB response message; client load "
+                 "reporting interval = "
+              << client_stats_report_interval_.millis() << " milliseconds";
+        } else {
+          GRPC_TRACE_LOG(glb, INFO)
+              << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+              << ": Received initial LB response message; client load "
+                 "reporting NOT enabled";
         }
         seen_initial_response_ = true;
         break;
@@ -1194,13 +1190,11 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
         CHECK_NE(lb_call_, nullptr);
         auto serverlist_wrapper =
             MakeRefCounted<Serverlist>(std::move(response.serverlist));
-        if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-          LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-                    << ": Serverlist with "
-                    << serverlist_wrapper->serverlist().size()
-                    << " servers received:\n"
-                    << serverlist_wrapper->AsText();
-        }
+        GRPC_TRACE_LOG(glb, INFO)
+            << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+            << ": Serverlist with " << serverlist_wrapper->serverlist().size()
+            << " servers received:\n"
+            << serverlist_wrapper->AsText();
         seen_serverlist_ = true;
         // Start sending client load report only after we start using the
         // serverlist returned from the current LB call.
@@ -1214,11 +1208,10 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
         // Check if the serverlist differs from the previous one.
         if (grpclb_policy()->serverlist_ != nullptr &&
             *grpclb_policy()->serverlist_ == *serverlist_wrapper) {
-          if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-            LOG(INFO) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-                      << ": Incoming server list identical to current, "
-                         "ignoring.";
-          }
+          GRPC_TRACE_LOG(glb, INFO)
+              << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
+              << ": Incoming server list identical to current, "
+                 "ignoring.";
         } else {  // New serverlist.
           // Dispose of the fallback.
           // TODO(roth): Ideally, we should stay in fallback mode until we
@@ -1458,11 +1451,10 @@ GrpcLb::GrpcLb(Args args)
                   GRPC_ARG_GRPCLB_SUBCHANNEL_CACHE_INTERVAL_MS)
               .value_or(Duration::Milliseconds(
                   GRPC_GRPCLB_DEFAULT_SUBCHANNEL_DELETION_DELAY_MS)))) {
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << this << "] Will use '"
-              << std::string(channel_control_helper()->GetAuthority())
-              << "' as the server name for LB request.";
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << this << "] Will use '"
+      << std::string(channel_control_helper()->GetAuthority())
+      << "' as the server name for LB request.";
 }
 
 void GrpcLb::ShutdownLocked() {
@@ -1527,10 +1519,9 @@ class GrpcLb::NullLbTokenEndpointIterator final
   void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
       const override {
     parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
-      if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-        LOG(INFO) << "[grpclb " << this
-                  << "] fallback address: " << endpoint.ToString();
-      }
+      GRPC_TRACE_LOG(glb, INFO)
+          << "[grpclb " << this
+          << "] fallback address: " << endpoint.ToString();
       callback(EndpointAddresses(endpoint.addresses(),
                                  endpoint.args().SetObject(empty_token_)));
     });
@@ -1544,9 +1535,7 @@ class GrpcLb::NullLbTokenEndpointIterator final
 };
 
 absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << this << "] received update";
-  }
+  GRPC_TRACE_LOG(glb, INFO) << "[grpclb " << this << "] received update";
   const bool is_initial_update = lb_channel_ == nullptr;
   config_ = args.config.TakeAsSubclass<GrpcLbConfig>();
   CHECK(config_ != nullptr);
@@ -1658,21 +1647,20 @@ void GrpcLb::StartBalancerCallLocked() {
   // Init the LB call data.
   CHECK(lb_calld_ == nullptr);
   lb_calld_ = MakeOrphanable<BalancerCallState>(Ref());
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << this
-              << "] Query for backends (lb_channel: " << lb_channel_.get()
-              << ", lb_calld: " << lb_calld_.get() << ")";
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << this
+      << "] Query for backends (lb_channel: " << lb_channel_.get()
+      << ", lb_calld: " << lb_calld_.get() << ")";
   lb_calld_->StartQuery();
 }
 
 void GrpcLb::StartBalancerCallRetryTimerLocked() {
-  Duration timeout = lb_call_backoff_.NextAttemptTime() - Timestamp::Now();
+  Duration delay = lb_call_backoff_.NextAttemptDelay();
   if (GRPC_TRACE_FLAG_ENABLED(glb)) {
     LOG(INFO) << "[grpclb " << this << "] Connection to LB server lost...";
-    if (timeout > Duration::Zero()) {
+    if (delay > Duration::Zero()) {
       LOG(INFO) << "[grpclb " << this << "] ... retry_timer_active in "
-                << timeout.millis() << "ms.";
+                << delay.millis() << "ms.";
     } else {
       LOG(INFO) << "[grpclb " << this
                 << "] ... retry_timer_active immediately.";
@@ -1680,7 +1668,7 @@ void GrpcLb::StartBalancerCallRetryTimerLocked() {
   }
   lb_call_retry_timer_handle_ =
       channel_control_helper()->GetEventEngine()->RunAfter(
-          timeout,
+          delay,
           [self = RefAsSubclass<GrpcLb>(
                DEBUG_LOCATION, "on_balancer_call_retry_timer")]() mutable {
             ApplicationCallbackExecCtx callback_exec_ctx;
@@ -1697,9 +1685,8 @@ void GrpcLb::StartBalancerCallRetryTimerLocked() {
 void GrpcLb::OnBalancerCallRetryTimerLocked() {
   lb_call_retry_timer_handle_.reset();
   if (!shutting_down_ && lb_calld_ == nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-      LOG(INFO) << "[grpclb " << this << "] Restarting call to LB server";
-    }
+    GRPC_TRACE_LOG(glb, INFO)
+        << "[grpclb " << this << "] Restarting call to LB server";
     StartBalancerCallLocked();
   }
 }
@@ -1765,10 +1752,9 @@ OrphanablePtr<LoadBalancingPolicy> GrpcLb::CreateChildPolicyLocked(
       std::make_unique<Helper>(RefAsSubclass<GrpcLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args), &glb_trace);
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << this << "] Created new child policy handler ("
-              << lb_policy.get() << ")";
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << this << "] Created new child policy handler ("
+      << lb_policy.get() << ")";
   // Add the gRPC LB's interested_parties pollset_set to that of the newly
   // created child policy. This will make the child policy progress upon
   // activity on gRPC LB, which in turn is tied to the application's call.
@@ -1819,10 +1805,9 @@ void GrpcLb::CreateOrUpdateChildPolicyLocked() {
     child_policy_ = CreateChildPolicyLocked(update_args.args);
   }
   // Update the policy.
-  if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-    LOG(INFO) << "[grpclb " << this << "] Updating child policy handler "
-              << child_policy_.get();
-  }
+  GRPC_TRACE_LOG(glb, INFO)
+      << "[grpclb " << this << "] Updating child policy handler "
+      << child_policy_.get();
   // TODO(roth): If we're in fallback mode and the child policy rejects the
   // update, we should propagate that failure back to the resolver somehow.
   (void)child_policy_->UpdateLocked(std::move(update_args));
@@ -1864,10 +1849,9 @@ void GrpcLb::OnSubchannelCacheTimerLocked() {
     subchannel_cache_timer_handle_.reset();
     auto it = cached_subchannels_.begin();
     if (it != cached_subchannels_.end()) {
-      if (GRPC_TRACE_FLAG_ENABLED(glb)) {
-        LOG(INFO) << "[grpclb " << this << "] removing " << it->second.size()
-                  << " subchannels from cache";
-      }
+      GRPC_TRACE_LOG(glb, INFO)
+          << "[grpclb " << this << "] removing " << it->second.size()
+          << " subchannels from cache";
       cached_subchannels_.erase(it);
     }
     if (!cached_subchannels_.empty()) {

data/src/core/load_balancing/health_check_client.cc

@@ -146,11 +146,9 @@ void HealthProducer::HealthChecker::OnConnectivityStateChangeLocked(
 
 void HealthProducer::HealthChecker::NotifyWatchersLocked(
     grpc_connectivity_state state, absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthProducer " << producer_.get() << " HealthChecker "
-              << this << ": reporting state " << ConnectivityStateName(state)
-              << " to watchers";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthProducer " << producer_.get() << " HealthChecker " << this
+      << ": reporting state " << ConnectivityStateName(state) << " to watchers";
   work_serializer_->Schedule(
       [self = Ref(), state, status = std::move(status)]() {
         MutexLock lock(&self->producer_->mu_);
@@ -285,11 +283,10 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
   void SetHealthStatusLocked(SubchannelStreamClient* client,
                              grpc_connectivity_state state,
                              const char* reason) {
-    if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-      LOG(INFO) << "HealthCheckClient " << client
-                << ": setting state=" << ConnectivityStateName(state)
-                << " reason=" << reason;
-    }
+    GRPC_TRACE_LOG(health_check_client, INFO)
+        << "HealthCheckClient " << client
+        << ": setting state=" << ConnectivityStateName(state)
+        << " reason=" << reason;
     health_checker_->OnHealthWatchStatusChange(
         state, state == GRPC_CHANNEL_TRANSIENT_FAILURE
                    ? absl::UnavailableError(reason)
@@ -300,11 +297,9 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
 };
 
 void HealthProducer::HealthChecker::StartHealthStreamLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthProducer " << producer_.get() << " HealthChecker "
-              << this << ": creating HealthClient for \""
-              << health_check_service_name_ << "\"";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthProducer " << producer_.get() << " HealthChecker " << this
+      << ": creating HealthClient for \"" << health_check_service_name_ << "\"";
   stream_client_ = MakeOrphanable<SubchannelStreamClient>(
       producer_->connected_subchannel_, producer_->subchannel_->pollset_set(),
       std::make_unique<HealthStreamEventHandler>(Ref()),
@@ -341,10 +336,9 @@ class HealthProducer::ConnectivityWatcher final
 //
 
 void HealthProducer::Start(RefCountedPtr<Subchannel> subchannel) {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthProducer " << this << ": starting with subchannel "
-              << subchannel.get();
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthProducer " << this << ": starting with subchannel "
+      << subchannel.get();
   subchannel_ = std::move(subchannel);
   {
     MutexLock lock(&mu_);
@@ -357,9 +351,8 @@ void HealthProducer::Start(RefCountedPtr<Subchannel> subchannel) {
 }
 
 void HealthProducer::Orphaned() {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthProducer " << this << ": shutting down";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthProducer " << this << ": shutting down";
   {
     MutexLock lock(&mu_);
     health_checkers_.clear();
@@ -407,11 +400,10 @@ void HealthProducer::RemoveWatcher(
 
 void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
                                                const absl::Status& status) {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthProducer " << this
-              << ": subchannel state update: state="
-              << ConnectivityStateName(state) << " status=" << status;
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthProducer " << this
+      << ": subchannel state update: state=" << ConnectivityStateName(state)
+      << " status=" << status;
   MutexLock lock(&mu_);
   state_ = state;
   status_ = status;
@@ -433,11 +425,10 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
 //
 
 HealthWatcher::~HealthWatcher() {
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthWatcher " << this << ": unregistering from producer "
-              << producer_.get() << " (health_check_service_name=\""
-              << health_check_service_name_.value_or("N/A") << "\")";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthWatcher " << this << ": unregistering from producer "
+      << producer_.get() << " (health_check_service_name=\""
+      << health_check_service_name_.value_or("N/A") << "\")";
   if (producer_ != nullptr) {
     producer_->RemoveWatcher(this, health_check_service_name_);
   }
@@ -467,12 +458,11 @@ void HealthWatcher::SetSubchannel(Subchannel* subchannel) {
   if (created) producer_->Start(subchannel->Ref());
   // Register ourself with the producer.
   producer_->AddWatcher(this, health_check_service_name_);
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "HealthWatcher " << this << ": registered with producer "
-              << producer_.get() << " (created=" << created
-              << ", health_check_service_name=\""
-              << health_check_service_name_.value_or("N/A") << "\")";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "HealthWatcher " << this << ": registered with producer "
+      << producer_.get() << " (created=" << created
+      << ", health_check_service_name=\""
+      << health_check_service_name_.value_or("N/A") << "\")";
 }
 
 void HealthWatcher::Notify(grpc_connectivity_state state, absl::Status status) {
@@ -498,10 +488,9 @@ MakeHealthCheckWatcher(
     health_check_service_name =
         args.GetOwnedString(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME);
   }
-  if (GRPC_TRACE_FLAG_ENABLED(health_check_client)) {
-    LOG(INFO) << "creating HealthWatcher -- health_check_service_name=\""
-              << health_check_service_name.value_or("N/A") << "\"";
-  }
+  GRPC_TRACE_LOG(health_check_client, INFO)
+      << "creating HealthWatcher -- health_check_service_name=\""
+      << health_check_service_name.value_or("N/A") << "\"";
   return std::make_unique<HealthWatcher>(std::move(work_serializer),
                                          std::move(health_check_service_name),
                                          std::move(watcher));

data/src/core/load_balancing/oob_backend_metric.cc

@@ -274,10 +274,8 @@ void OrcaProducer::MaybeStartStreamLocked() {
 
 void OrcaProducer::NotifyWatchers(
     const BackendMetricData& backend_metric_data) {
-  if (GRPC_TRACE_FLAG_ENABLED(orca_client)) {
-    LOG(INFO) << "OrcaProducer " << this
-              << ": reporting backend metrics to watchers";
-  }
+  GRPC_TRACE_LOG(orca_client, INFO)
+      << "OrcaProducer " << this << ": reporting backend metrics to watchers";
   MutexLock lock(&mu_);
   for (OrcaWatcher* watcher : watchers_) {
     watcher->watcher()->OnBackendMetricReport(backend_metric_data);