grpc 1.64.0 → 1.65.2

data/src/core/xds/xds_client/xds_client.cc

@@ -68,9 +68,6 @@ namespace grpc_core {
 
 using ::grpc_event_engine::experimental::EventEngine;
 
-TraceFlag grpc_xds_client_trace(false, "xds_client");
-TraceFlag grpc_xds_client_refcount_trace(false, "xds_client_refcount");
-
 //
 // Internal class declarations
 //
@@ -253,7 +250,7 @@ class XdsClient::XdsChannel::AdsCall final
     }
 
     void OnTimer() {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
         gpr_log(GPR_INFO,
                 "[xds_client %p] xds server %s: timeout obtaining resource "
                 "{type=%s name=%s} from xds server",
@@ -456,12 +453,12 @@ class XdsClient::XdsChannel::LrsCall final
 
 XdsClient::XdsChannel::XdsChannel(WeakRefCountedPtr<XdsClient> xds_client,
                                   const XdsBootstrap::XdsServer& server)
-    : DualRefCounted<XdsChannel>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace) ? "XdsChannel"
-                                                                  : nullptr),
+    : DualRefCounted<XdsChannel>(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
+                                     ? "XdsChannel"
+                                     : nullptr),
       xds_client_(std::move(xds_client)),
       server_(server) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating channel %p for server %s",
             xds_client_.get(), this, server.server_uri().c_str());
   }
@@ -478,7 +475,7 @@ XdsClient::XdsChannel::XdsChannel(WeakRefCountedPtr<XdsClient> xds_client,
 }
 
 XdsClient::XdsChannel::~XdsChannel() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] destroying xds channel %p for server %s",
             xds_client(), this, server_.server_uri().c_str());
   }
@@ -490,7 +487,7 @@ XdsClient::XdsChannel::~XdsChannel() {
 // called from DualRefCounted::Unref, which cannot have a lock annotation for
 // a lock in this subclass.
 void XdsClient::XdsChannel::Orphaned() ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] orphaning xds channel %p for server %s",
             xds_client(), this, server_.server_uri().c_str());
   }
@@ -578,7 +575,7 @@ bool XdsClient::XdsChannel::MaybeFallbackLocked(
             type_resource.first, {authority, key_state.first});
       }
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] authority %s: added fallback server %s (%s)",
               xds_client_.get(), authority.c_str(),
@@ -587,7 +584,7 @@ bool XdsClient::XdsChannel::MaybeFallbackLocked(
     }
     if (authority_state.xds_channels.back()->status().ok()) return true;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] authority %s: No fallback server",
             xds_client_.get(), authority.c_str());
   }
@@ -607,7 +604,7 @@ void XdsClient::XdsChannel::SetHealthyLocked() {
     auto channel_it = std::find(channels.begin(), channels.end(), this);
     // Skip if this is not on the list
     if (channel_it != channels.end()) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
         gpr_log(GPR_INFO, "[xds_client %p] authority %s: Falling forward to %s",
                 xds_client_.get(), authority.first.c_str(),
                 server_.server_uri().c_str());
@@ -720,7 +717,7 @@ void XdsClient::XdsChannel::RetryableCall<T>::StartNewCallLocked() {
   if (shutting_down_) return;
   CHECK(xds_channel_->transport_ != nullptr);
   CHECK(call_ == nullptr);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: start new call from retryable "
             "call %p",
@@ -737,7 +734,7 @@ void XdsClient::XdsChannel::RetryableCall<T>::StartRetryTimerLocked() {
   const Timestamp next_attempt_time = backoff_.NextAttemptTime();
   const Duration timeout =
       std::max(next_attempt_time - Timestamp::Now(), Duration::Zero());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: call attempt failed; "
             "retry timer will fire in %" PRId64 "ms.",
@@ -759,7 +756,7 @@ void XdsClient::XdsChannel::RetryableCall<T>::OnRetryTimer() {
   if (timer_handle_.has_value()) {
     timer_handle_.reset();
     if (shutting_down_) return;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: retry timer fired (retryable "
               "call: %p)",
@@ -797,7 +794,7 @@ class XdsClient::XdsChannel::AdsCall::AdsReadDelayHandle final
 absl::Status
 XdsClient::XdsChannel::AdsCall::AdsResponseParser::ProcessAdsResponseFields(
     AdsResponseFields fields) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(
         GPR_INFO,
         "[xds_client %p] xds server %s: received ADS response: type_url=%s, "
@@ -863,7 +860,7 @@ void XdsClient::XdsChannel::AdsCall::AdsResponseParser::ParseResource(
   }
   // Parse the resource.
   XdsResourceType::DecodeContext context = {
-      xds_client(), ads_call_->xds_channel()->server_, &grpc_xds_client_trace,
+      xds_client(), ads_call_->xds_channel()->server_, &xds_client_trace,
       xds_client()->def_pool_.ptr(), arena};
   XdsResourceType::DecodeResult decode_result =
       result_.type->Decode(context, serialized_resource);
@@ -964,7 +961,7 @@ void XdsClient::XdsChannel::AdsCall::AdsResponseParser::ParseResource(
   if (resource_state.resource != nullptr &&
       result_.type->ResourcesEqual(resource_state.resource.get(),
                                    decode_result.resource->get())) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] %s resource %s identical to current, ignoring.",
               xds_client(), result_.type_url.c_str(),
@@ -1003,8 +1000,7 @@ void XdsClient::XdsChannel::AdsCall::AdsResponseParser::
 XdsClient::XdsChannel::AdsCall::AdsCall(
     RefCountedPtr<RetryableCall<AdsCall>> retryable_call)
     : InternallyRefCounted<AdsCall>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace) ? "AdsCall"
-                                                                  : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(xds_client_refcount) ? "AdsCall" : nullptr),
       retryable_call_(std::move(retryable_call)) {
   CHECK_NE(xds_client(), nullptr);
   // Init the ADS call.
@@ -1018,7 +1014,7 @@ XdsClient::XdsChannel::AdsCall::AdsCall(
                   RefCountedPtr<AdsCall>(this)));
   CHECK(streaming_call_ != nullptr);
   // Start the call.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: starting ADS call "
             "(ads_call: %p, streaming_call: %p)",
@@ -1072,7 +1068,7 @@ void XdsClient::XdsChannel::AdsCall::SendMessageLocked(
       state.nonce, ResourceNamesForRequest(type), state.status,
       !sent_initial_message_);
   sent_initial_message_ = true;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: sending ADS request: type=%s "
             "version=%s nonce=%s error=%s",
@@ -1262,7 +1258,7 @@ void XdsClient::XdsChannel::AdsCall::OnRecvMessage(absl::string_view payload) {
 void XdsClient::XdsChannel::AdsCall::OnStatusReceived(absl::Status status) {
   {
     MutexLock lock(&xds_client()->mu_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: ADS call status received "
               "(xds_channel=%p, ads_call=%p, streaming_call=%p): %s",
@@ -1335,7 +1331,7 @@ void XdsClient::XdsChannel::LrsCall::Timer::Orphan() {
 }
 
 void XdsClient::XdsChannel::LrsCall::Timer::ScheduleNextReportLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: scheduling next load report in %s",
             xds_client(),
@@ -1364,8 +1360,7 @@ void XdsClient::XdsChannel::LrsCall::Timer::OnNextReportTimer() {
 XdsClient::XdsChannel::LrsCall::LrsCall(
     RefCountedPtr<RetryableCall<LrsCall>> retryable_call)
     : InternallyRefCounted<LrsCall>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace) ? "LrsCall"
-                                                                  : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(xds_client_refcount) ? "LrsCall" : nullptr),
       retryable_call_(std::move(retryable_call)) {
   // Init the LRS call. Note that the call will progress every time there's
   // activity in xds_client()->interested_parties_, which is comprised of
@@ -1380,7 +1375,7 @@ XdsClient::XdsChannel::LrsCall::LrsCall(
                   RefCountedPtr<LrsCall>(this)));
   CHECK(streaming_call_ != nullptr);
   // Start the call.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: starting LRS call (lrs_call=%p, "
             "streaming_call=%p)",
@@ -1494,7 +1489,7 @@ void XdsClient::XdsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
     return;
   }
   seen_response_ = true;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(
         GPR_INFO,
         "[xds_client %p] xds server %s: LRS response received, %" PRIuPTR
@@ -1513,7 +1508,7 @@ void XdsClient::XdsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
       Duration::Milliseconds(GRPC_XDS_MIN_CLIENT_LOAD_REPORTING_INTERVAL_MS)) {
     new_load_reporting_interval =
         Duration::Milliseconds(GRPC_XDS_MIN_CLIENT_LOAD_REPORTING_INTERVAL_MS);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: increased load_report_interval "
               "to minimum value %dms",
@@ -1525,7 +1520,7 @@ void XdsClient::XdsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
   if (send_all_clusters == send_all_clusters_ &&
       cluster_names_ == new_cluster_names &&
       load_reporting_interval_ == new_load_reporting_interval) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: incoming LRS response identical "
               "to current, ignoring.",
@@ -1549,7 +1544,7 @@ void XdsClient::XdsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
 
 void XdsClient::XdsChannel::LrsCall::OnStatusReceived(absl::Status status) {
   MutexLock lock(&xds_client()->mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] xds server %s: LRS call status received "
             "(xds_channel=%p, lrs_call=%p, streaming_call=%p): %s",
@@ -1585,18 +1580,17 @@ XdsClient::XdsClient(
     std::string user_agent_name, std::string user_agent_version,
     Duration resource_request_timeout)
     : DualRefCounted<XdsClient>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace) ? "XdsClient"
-                                                                  : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(xds_client_refcount) ? "XdsClient" : nullptr),
       bootstrap_(std::move(bootstrap)),
       transport_factory_(std::move(transport_factory)),
       request_timeout_(resource_request_timeout),
       xds_federation_enabled_(XdsFederationEnabled()),
-      api_(this, &grpc_xds_client_trace, bootstrap_->node(), &def_pool_,
+      api_(this, &xds_client_trace, bootstrap_->node(), &def_pool_,
            std::move(user_agent_name), std::move(user_agent_version)),
       work_serializer_(engine),
       engine_(std::move(engine)),
       metrics_reporter_(std::move(metrics_reporter)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating xds client", this);
   }
   CHECK(bootstrap_ != nullptr);
@@ -1607,13 +1601,13 @@ XdsClient::XdsClient(
 }
 
 XdsClient::~XdsClient() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] destroying xds client", this);
   }
 }
 
 void XdsClient::Orphaned() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] shutting down xds client", this);
   }
   MutexLock lock(&mu_);
@@ -1735,7 +1729,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
       // If we already have a cached value for the resource, notify the new
       // watcher immediately.
       if (resource_state.resource != nullptr) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
           gpr_log(GPR_INFO,
                   "[xds_client %p] returning cached listener data for %s", this,
                   std::string(name).c_str());
@@ -1749,7 +1743,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
             DEBUG_LOCATION);
       } else if (resource_state.meta.client_status ==
                  XdsApi::ResourceMetadata::DOES_NOT_EXIST) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
           gpr_log(GPR_INFO,
                   "[xds_client %p] reporting cached does-not-exist for %s",
                   this, std::string(name).c_str());
@@ -1761,7 +1755,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
             DEBUG_LOCATION);
       } else if (resource_state.meta.client_status ==
                  XdsApi::ResourceMetadata::NACKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
           gpr_log(
               GPR_INFO,
               "[xds_client %p] reporting cached validation failure for %s: %s",
@@ -1786,7 +1780,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
     }
     absl::Status channel_status = authority_state.xds_channels.back()->status();
     if (!channel_status.ok()) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
         gpr_log(GPR_INFO,
                 "[xds_client %p] returning cached channel error for %s: %s",
                 this, std::string(name).c_str(),
@@ -2091,7 +2085,7 @@ void XdsClient::NotifyWatchersOnResourceDoesNotExist(
 XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
     const XdsBootstrap::XdsServer& xds_server, bool send_all_clusters,
     const std::set<std::string>& clusters) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] start building load report", this);
   }
   XdsApi::ClusterLoadReportMap snapshot_map;
@@ -2118,7 +2112,7 @@ XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
     if (load_report.drop_stats != nullptr) {
       snapshot.dropped_requests +=
           load_report.drop_stats->GetSnapshotAndReset();
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
         gpr_log(GPR_INFO,
                 "[xds_client %p] cluster=%s eds_service_name=%s drop_stats=%p",
                 this, cluster_key.first.c_str(), cluster_key.second.c_str(),
@@ -2136,7 +2130,7 @@ XdsApi::ClusterLoadReportMap XdsClient::BuildLoadReportSnapshotLocked(
       if (locality_state.locality_stats != nullptr) {
         locality_snapshot +=
             locality_state.locality_stats->GetSnapshotAndReset();
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
           gpr_log(GPR_INFO,
                   "[xds_client %p] cluster=%s eds_service_name=%s "
                   "locality=%s locality_stats=%p",

data/src/core/xds/xds_client/xds_client.h

@@ -55,9 +55,6 @@ namespace testing {
 class XdsClientTestPeer;
 }
 
-extern TraceFlag grpc_xds_client_trace;
-extern TraceFlag grpc_xds_client_refcount_trace;
-
 class XdsClient : public DualRefCounted<XdsClient> {
  public:
   // The authority reported for old-style (non-xdstp) resource names.

data/src/core/xds/xds_client/xds_client_stats.cc

@@ -43,14 +43,14 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
                                          absl::string_view lrs_server,
                                          absl::string_view cluster_name,
                                          absl::string_view eds_service_name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterDropStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
       lrs_server_(lrs_server),
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO, "[xds_client %p] created drop stats %p for {%s, %s, %s}",
             xds_client_.get(), this, std::string(lrs_server_).c_str(),
             std::string(cluster_name_).c_str(),
@@ -59,7 +59,7 @@ XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
 }
 
 XdsClusterDropStats::~XdsClusterDropStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
     gpr_log(GPR_INFO,
             "[xds_client %p] destroying drop stats %p for {%s, %s, %s}",
             xds_client_.get(), this, std::string(lrs_server_).c_str(),
@@ -96,7 +96,7 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
     RefCountedPtr<XdsClient> xds_client, absl::string_view lrs_server,
     absl::string_view cluster_name, absl::string_view eds_service_name,
     RefCountedPtr<XdsLocalityName> name)
-    : RefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_refcount_trace)
+    : RefCounted(GRPC_TRACE_FLAG_ENABLED(xds_client_refcount)
                      ? "XdsClusterLocalityStats"
                      : nullptr),
       xds_client_(std::move(xds_client)),
@@ -104,24 +104,26 @@ XdsClusterLocalityStats::XdsClusterLocalityStats(
       cluster_name_(cluster_name),
       eds_service_name_(eds_service_name),
       name_(std::move(name)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    gpr_log(
+        GPR_INFO,
+        "[xds_client %p] created locality stats %p for {%s, %s, %s, %s}",
+        xds_client_.get(), this, std::string(lrs_server_).c_str(),
+        std::string(cluster_name_).c_str(),
+        std::string(eds_service_name_).c_str(),
+        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
   }
 }
 
 XdsClusterLocalityStats::~XdsClusterLocalityStats() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
-            xds_client_.get(), this, std::string(lrs_server_).c_str(),
-            std::string(cluster_name_).c_str(),
-            std::string(eds_service_name_).c_str(),
-            name_->human_readable_string().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
+    gpr_log(
+        GPR_INFO,
+        "[xds_client %p] destroying locality stats %p for {%s, %s, %s, %s}",
+        xds_client_.get(), this, std::string(lrs_server_).c_str(),
+        std::string(cluster_name_).c_str(),
+        std::string(eds_service_name_).c_str(),
+        name_ == nullptr ? "<none>" : name_->human_readable_string().c_str());
   }
   xds_client_->RemoveClusterLocalityStats(lrs_server_, cluster_name_,
                                           eds_service_name_, name_, this);

data/src/core/xds/xds_client/xds_client_stats.h

@@ -31,13 +31,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/util/useful.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
 namespace grpc_core {

data/src/ruby/bin/math_pb.rb

@@ -8,28 +8,7 @@ require 'google/protobuf'
 descriptor_data = "\n\nmath.proto\x12\x04math\",\n\x07\x44ivArgs\x12\x10\n\x08\x64ividend\x18\x01 \x01(\x03\x12\x0f\n\x07\x64ivisor\x18\x02 \x01(\x03\"/\n\x08\x44ivReply\x12\x10\n\x08quotient\x18\x01 \x01(\x03\x12\x11\n\tremainder\x18\x02 \x01(\x03\"\x18\n\x07\x46ibArgs\x12\r\n\x05limit\x18\x01 \x01(\x03\"\x12\n\x03Num\x12\x0b\n\x03num\x18\x01 \x01(\x03\"\x19\n\x08\x46ibReply\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x32\xa4\x01\n\x04Math\x12&\n\x03\x44iv\x12\r.math.DivArgs\x1a\x0e.math.DivReply\"\x00\x12.\n\x07\x44ivMany\x12\r.math.DivArgs\x1a\x0e.math.DivReply\"\x00(\x01\x30\x01\x12#\n\x03\x46ib\x12\r.math.FibArgs\x1a\t.math.Num\"\x00\x30\x01\x12\x1f\n\x03Sum\x12\t.math.Num\x1a\t.math.Num\"\x00(\x01\x62\x06proto3"
 
 pool = Google::Protobuf::DescriptorPool.generated_pool
-
-begin
-  pool.add_serialized_file(descriptor_data)
-rescue TypeError
-  # Compatibility code: will be removed in the next major version.
-  require 'google/protobuf/descriptor_pb'
-  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
-  parsed.clear_dependency
-  serialized = parsed.class.encode(parsed)
-  file = pool.add_serialized_file(serialized)
-  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
-  imports = [
-  ]
-  imports.each do |type_name, expected_filename|
-    import_file = pool.lookup(type_name).file_descriptor
-    if import_file.name != expected_filename
-      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
-    end
-  end
-  warn "Each proto file must use a consistent fully-qualified name."
-  warn "This will become an error in the next major version."
-end
+pool.add_serialized_file(descriptor_data)
 
 module Math
   DivArgs = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("math.DivArgs").msgclass

data/src/ruby/ext/grpc/rb_call.c

@@ -808,6 +808,12 @@ struct call_run_batch_args {
   run_batch_stack* st;
 };
 
+static void cancel_call_unblock_func(void* arg) {
+  gpr_log(GPR_INFO, "GRPC_RUBY: cancel_call_unblock_func");
+  grpc_call* call = (grpc_call*)arg;
+  grpc_call_cancel(call, NULL);
+}
+
 static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
   grpc_rb_fork_unsafe_begin();
   struct call_run_batch_args* args = (struct call_run_batch_args*)value_args;
@@ -830,7 +836,8 @@ static VALUE grpc_rb_call_run_batch_try(VALUE value_args) {
              grpc_call_error_detail_of(err), err);
   }
   ev = rb_completion_queue_pluck(args->call->queue, tag,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+                                 gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 cancel_call_unblock_func, args->call->wrapped);
   if (!ev.success) {
     rb_raise(grpc_rb_eCallError, "call#run_batch failed somehow");
   }

data/src/ruby/ext/grpc/rb_completion_queue.c

@@ -35,23 +35,15 @@ typedef struct next_call_stack {
   grpc_event event;
   gpr_timespec timeout;
   void* tag;
-  volatile int interrupted;
+  void (*unblock_func)(void*);
+  void* unblock_func_arg;
 } next_call_stack;
 
 /* Calls grpc_completion_queue_pluck without holding the ruby GIL */
 static void* grpc_rb_completion_queue_pluck_no_gil(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  gpr_timespec increment = gpr_time_from_millis(20, GPR_TIMESPAN);
-  gpr_timespec deadline;
-  do {
-    deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), increment);
-    next_call->event = grpc_completion_queue_pluck(
-        next_call->cq, next_call->tag, deadline, NULL);
-    if (next_call->event.type != GRPC_QUEUE_TIMEOUT ||
-        gpr_time_cmp(deadline, next_call->timeout) > 0) {
-      break;
-    }
-  } while (!next_call->interrupted);
+  next_call->event = grpc_completion_queue_pluck(next_call->cq, next_call->tag,
+                                                 next_call->timeout, NULL);
   return NULL;
 }
 
@@ -65,37 +57,28 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq) {
   grpc_completion_queue_destroy(cq);
 }
 
-static void unblock_func(void* param) {
+static void outer_unblock_func(void* param) {
   next_call_stack* const next_call = (next_call_stack*)param;
-  next_call->interrupted = 1;
+  if (next_call->unblock_func == NULL) return;
+  next_call->unblock_func(next_call->unblock_func_arg);
 }
 
 /* Does the same thing as grpc_completion_queue_pluck, while properly releasing
    the GVL and handling interrupts */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline, void* reserved) {
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg) {
   next_call_stack next_call;
   MEMZERO(&next_call, next_call_stack, 1);
   next_call.cq = queue;
   next_call.timeout = deadline;
   next_call.tag = tag;
   next_call.event.type = GRPC_QUEUE_TIMEOUT;
-  (void)reserved;
-  /* Loop until we finish a pluck without an interruption. The internal
-     pluck function runs either until it is interrupted or it gets an
-     event, or time runs out.
-
-     The basic reason we need this relatively complicated construction is that
-     we need to re-acquire the GVL when an interrupt comes in, so that the ruby
-     interpreter can do what it needs to do with the interrupt. But we also need
-     to get back to plucking when the interrupt has been handled. */
-  do {
-    next_call.interrupted = 0;
-    rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
-                               (void*)&next_call, unblock_func,
-                               (void*)&next_call);
-    /* If an interrupt prevented pluck from returning useful information, then
-       any plucks that did complete must have timed out */
-  } while (next_call.interrupted && next_call.event.type == GRPC_QUEUE_TIMEOUT);
+  next_call.unblock_func = unblock_func;
+  next_call.unblock_func_arg = unblock_func_arg;
+  rb_thread_call_without_gvl(grpc_rb_completion_queue_pluck_no_gil,
+                             (void*)&next_call, outer_unblock_func,
+                             (void*)&next_call);
   return next_call.event;
 }

data/src/ruby/ext/grpc/rb_completion_queue.h

@@ -29,8 +29,14 @@ void grpc_rb_completion_queue_destroy(grpc_completion_queue* cq);
  * Makes the implementation of CompletionQueue#pluck available in other files
  *
  * This avoids having code that holds the GIL repeated at multiple sites.
+ *
+ * unblock_func is invoked with the provided argument to unblock the CQ
+ * operation in the event of process termination (e.g. a signal), but
+ * unblock_func may be NULL in which case it's unused.
  */
 grpc_event rb_completion_queue_pluck(grpc_completion_queue* queue, void* tag,
-                                     gpr_timespec deadline, void* reserved);
+                                     gpr_timespec deadline,
+                                     void (*unblock_func)(void* param),
+                                     void* unblock_func_arg);
 
 #endif /* GRPC_RB_COMPLETION_QUEUE_H_ */

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -747,13 +747,13 @@ extern gpr_should_log_type gpr_should_log_import;
 typedef void(*gpr_log_message_type)(const char* file, int line, gpr_log_severity severity, const char* message);
 extern gpr_log_message_type gpr_log_message_import;
 #define gpr_log_message gpr_log_message_import
-typedef void(*gpr_set_log_verbosity_type)(gpr_log_severity min_severity_to_print);
+typedef void(*gpr_set_log_verbosity_type)(gpr_log_severity deprecated_setting);
 extern gpr_set_log_verbosity_type gpr_set_log_verbosity_import;
 #define gpr_set_log_verbosity gpr_set_log_verbosity_import
 typedef void(*gpr_log_verbosity_init_type)(void);
 extern gpr_log_verbosity_init_type gpr_log_verbosity_init_import;
 #define gpr_log_verbosity_init gpr_log_verbosity_init_import
-typedef void(*gpr_set_log_function_type)(gpr_log_func func);
+typedef void(*gpr_set_log_function_type)(gpr_log_func deprecated_setting);
 extern gpr_set_log_function_type gpr_set_log_function_import;
 #define gpr_set_log_function gpr_set_log_function_import
 typedef void(*gpr_assertion_failed_type)(const char* filename, int line, const char* message);