grpc 1.64.0 → 1.65.0

data/src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -26,6 +26,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -77,14 +78,8 @@ using grpc_event_engine::experimental::EventEngine;
 // TODO(hork): Add a test that checks for proper authority from balancer
 // addresses.
 
-// TODO(hork): replace this with `dns_resolver` when all other resolver
-// implementations are removed.
-TraceFlag grpc_event_engine_client_channel_resolver_trace(
-    false, "event_engine_client_channel_resolver");
-
 #define GRPC_EVENT_ENGINE_RESOLVER_TRACE(format, ...)                    \
-  if (GRPC_TRACE_FLAG_ENABLED(                                           \
-          grpc_event_engine_client_channel_resolver_trace)) {            \
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine_client_channel_resolver)) {   \
     gpr_log(GPR_DEBUG, "(event_engine client channel resolver) " format, \
             __VA_ARGS__);                                                \
   }
@@ -184,7 +179,7 @@ EventEngineClientChannelDNSResolver::EventEngineClientChannelDNSResolver(
                           .set_jitter(GRPC_DNS_RECONNECT_JITTER)
                           .set_max_backoff(Duration::Milliseconds(
                               GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)),
-                      &grpc_event_engine_client_channel_resolver_trace),
+                      &event_engine_client_channel_resolver_trace),
       request_service_config_(
           !channel_args()
                .GetBool(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION)
@@ -567,7 +562,7 @@ absl::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
 bool EventEngineClientChannelDNSResolverFactory::IsValidUri(
     const URI& uri) const {
   if (absl::StripPrefix(uri.path(), "/").empty()) {
-    gpr_log(GPR_ERROR, "no server name supplied in dns URI");
+    LOG(ERROR) << "no server name supplied in dns URI";
     return false;
   }
   return true;

data/src/core/resolver/dns/event_engine/service_config_helper.cc

@@ -25,11 +25,11 @@
 
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/gethostname.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/json/json_reader.h"
-#include "src/core/lib/json/json_writer.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/json/json_reader.h"
+#include "src/core/util/json/json_writer.h"
 
 namespace grpc_core {
 

data/src/core/resolver/dns/native/dns_resolver.cc

@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "absl/functional/bind_front.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -56,8 +57,6 @@ namespace grpc_core {
 
 namespace {
 
-TraceFlag grpc_trace_dns_resolver(false, "dns_resolver");
-
 class NativeClientChannelDNSResolver final : public PollingResolver {
  public:
   NativeClientChannelDNSResolver(ResolverArgs args,
@@ -91,14 +90,14 @@ NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
                           .set_jitter(GRPC_DNS_RECONNECT_JITTER)
                           .set_max_backoff(Duration::Milliseconds(
                               GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)),
-                      &grpc_trace_dns_resolver) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+                      &dns_resolver_trace) {
+  if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] created", this);
   }
 }
 
 NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+  if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] destroyed", this);
   }
 }
@@ -109,7 +108,7 @@ OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
       absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this),
       name_to_resolve(), kDefaultSecurePort, kDefaultDNSRequestTimeout,
       interested_parties(), /*name_server=*/"");
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+  if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] starting request=%p", this,
             DNSResolver::HandleToString(dns_request_handle).c_str());
   }
@@ -118,7 +117,7 @@ OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
 
 void NativeClientChannelDNSResolver::OnResolved(
     absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_dns_resolver)) {
+  if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
     gpr_log(GPR_DEBUG, "[dns_resolver=%p] request complete, status=\"%s\"",
             this, addresses_or.status().ToString().c_str());
   }
@@ -150,11 +149,11 @@ class NativeClientChannelDNSResolverFactory final : public ResolverFactory {
 
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(GPR_ERROR, "authority based dns uri's not supported");
+      LOG(ERROR) << "authority based dns uri's not supported";
       return false;
     }
     if (absl::StripPrefix(uri.path(), "/").empty()) {
-      gpr_log(GPR_ERROR, "no server name supplied in dns URI");
+      LOG(ERROR) << "no server name supplied in dns URI";
       return false;
     }
     return true;

data/src/core/resolver/endpoint_addresses.cc

@@ -35,7 +35,7 @@
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 // IWYU pragma: no_include <sys/socket.h>
 

data/src/core/resolver/fake/fake_resolver.cc

@@ -31,12 +31,12 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/uri/uri_parser.h"
 #include "src/core/resolver/resolver_factory.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/resolver/fake/fake_resolver.h

@@ -27,12 +27,12 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/notification.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/resolver.h"
+#include "src/core/util/useful.h"
 
 #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \
   "grpc.fake_resolver.response_generator"

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -22,6 +22,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -29,10 +30,8 @@
 #include "absl/types/optional.h"
 
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/gcp/metadata_query.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -42,14 +41,15 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 #include "src/core/lib/uri/uri_parser.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/resolver/resolver_factory.h"
 #include "src/core/resolver/resolver_registry.h"
+#include "src/core/util/gcp_metadata_query.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_writer.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 
@@ -81,10 +81,10 @@ class GoogleCloud2ProdResolver final : public Resolver {
   std::string metadata_server_name_ = "metadata.google.internal.";
   bool shutdown_ = false;
 
-  OrphanablePtr<MetadataQuery> zone_query_;
+  OrphanablePtr<GcpMetadataQuery> zone_query_;
   absl::optional<std::string> zone_;
 
-  OrphanablePtr<MetadataQuery> ipv6_query_;
+  OrphanablePtr<GcpMetadataQuery> ipv6_query_;
   absl::optional<bool> supports_ipv6_;
 };
 
@@ -151,8 +151,8 @@ void GoogleCloud2ProdResolver::StartLocked() {
     return;
   }
   // Using xDS.  Start metadata server queries.
-  zone_query_ = MakeOrphanable<MetadataQuery>(
-      metadata_server_name_, std::string(MetadataQuery::kZoneAttribute),
+  zone_query_ = MakeOrphanable<GcpMetadataQuery>(
+      metadata_server_name_, std::string(GcpMetadataQuery::kZoneAttribute),
       &pollent_,
       [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
           std::string /* attribute */,
@@ -165,8 +165,8 @@ void GoogleCloud2ProdResolver::StartLocked() {
             DEBUG_LOCATION);
       },
       Duration::Seconds(10));
-  ipv6_query_ = MakeOrphanable<MetadataQuery>(
-      metadata_server_name_, std::string(MetadataQuery::kIPv6Attribute),
+  ipv6_query_ = MakeOrphanable<GcpMetadataQuery>(
+      metadata_server_name_, std::string(GcpMetadataQuery::kIPv6Attribute),
       &pollent_,
       [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
           std::string /* attribute */,
@@ -282,7 +282,7 @@ class GoogleCloud2ProdResolverFactory final : public ResolverFactory {
 
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      LOG(ERROR) << "google-c2p URI scheme does not support authorities";
       return false;
     }
     return true;
@@ -305,9 +305,8 @@ class ExperimentalGoogleCloud2ProdResolverFactory final
 
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
-      gpr_log(
-          GPR_ERROR,
-          "google-c2p-experimental URI scheme does not support authorities");
+      LOG(ERROR) << "google-c2p-experimental URI scheme does not support "
+                    "authorities";
       return false;
     }
     return true;

data/src/core/resolver/polling_resolver.cc

@@ -24,12 +24,12 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/backoff/backoff.h"
@@ -60,13 +60,13 @@ PollingResolver::PollingResolver(ResolverArgs args,
       min_time_between_resolutions_(min_time_between_resolutions),
       backoff_(backoff_options) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] created", this);
+    LOG(INFO) << "[polling resolver " << this << "] created";
   }
 }
 
 PollingResolver::~PollingResolver() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
+    LOG(INFO) << "[polling resolver " << this << "] destroying";
   }
 }
 
@@ -97,7 +97,7 @@ void PollingResolver::ResetBackoffLocked() {
 
 void PollingResolver::ShutdownLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] shutting down", this);
+    LOG(INFO) << "[polling resolver " << this << "] shutting down";
   }
   shutdown_ = true;
   MaybeCancelNextResolutionTimer();
@@ -119,9 +119,8 @@ void PollingResolver::ScheduleNextResolutionTimer(const Duration& timeout) {
 
 void PollingResolver::OnNextResolutionLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO,
-            "[polling resolver %p] re-resolution timer fired: shutdown_=%d",
-            this, shutdown_);
+    LOG(INFO) << "[polling resolver " << this
+              << "] re-resolution timer fired: shutdown_=" << shutdown_;
   }
   // If we haven't been cancelled nor shutdown, then start resolving.
   if (next_resolution_timer_handle_.has_value() && !shutdown_) {
@@ -133,8 +132,8 @@ void PollingResolver::OnNextResolutionLocked() {
 void PollingResolver::MaybeCancelNextResolutionTimer() {
   if (next_resolution_timer_handle_.has_value()) {
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-      gpr_log(GPR_INFO, "[polling resolver %p] cancel re-resolution timer",
-              this);
+      LOG(INFO) << "[polling resolver " << this
+                << "] cancel re-resolution timer";
     }
     channel_args_.GetObject<EventEngine>()->Cancel(
         *next_resolution_timer_handle_);
@@ -151,26 +150,24 @@ void PollingResolver::OnRequestComplete(Result result) {
 
 void PollingResolver::OnRequestCompleteLocked(Result result) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] request complete", this);
+    LOG(INFO) << "[polling resolver " << this << "] request complete";
   }
   request_.reset();
   if (!shutdown_) {
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-      gpr_log(GPR_INFO,
-              "[polling resolver %p] returning result: "
-              "addresses=%s, service_config=%s, resolution_note=%s",
-              this,
-              result.addresses.ok()
+      LOG(INFO)
+          << "[polling resolver " << this << "] returning result: addresses="
+          << (result.addresses.ok()
                   ? absl::StrCat("<", result.addresses->size(), " addresses>")
-                        .c_str()
-                  : result.addresses.status().ToString().c_str(),
-              result.service_config.ok()
+                  : result.addresses.status().ToString())
+          << ", service_config="
+          << (result.service_config.ok()
                   ? (*result.service_config == nullptr
                          ? "<null>"
                          : std::string((*result.service_config)->json_string())
                                .c_str())
-                  : result.service_config.status().ToString().c_str(),
-              result.resolution_note.c_str());
+                  : result.service_config.status().ToString())
+          << ", resolution_note=" << result.resolution_note;
     }
     CHECK(result.result_health_callback == nullptr);
     result.result_health_callback =
@@ -186,8 +183,8 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
 
 void PollingResolver::GetResultStatus(absl::Status status) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] result status from channel: %s",
-            this, status.ToString().c_str());
+    LOG(INFO) << "[polling resolver " << this
+              << "] result status from channel: " << status;
   }
   if (status.ok()) {
     // Reset backoff state so that we start from the beginning when the
@@ -210,10 +207,10 @@ void PollingResolver::GetResultStatus(absl::Status status) {
     CHECK(!next_resolution_timer_handle_.has_value());
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
       if (timeout > Duration::Zero()) {
-        gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
-                this, timeout.millis());
+        LOG(INFO) << "[polling resolver " << this << "] retrying in "
+                  << timeout.millis() << " ms";
       } else {
-        gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
+        LOG(INFO) << "[polling resolver " << this << "] retrying immediately";
       }
     }
     ScheduleNextResolutionTimer(timeout);
@@ -241,12 +238,11 @@ void PollingResolver::MaybeStartResolvingLocked() {
       if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
         const Duration last_resolution_ago =
             Timestamp::Now() - *last_resolution_timestamp_;
-        gpr_log(GPR_INFO,
-                "[polling resolver %p] in cooldown from last resolution "
-                "(from %" PRId64 " ms ago); will resolve again in %" PRId64
-                " ms",
-                this, last_resolution_ago.millis(),
-                time_until_next_resolution.millis());
+        LOG(INFO) << "[polling resolver " << this
+                  << "] in cooldown from last resolution (from "
+                  << last_resolution_ago.millis()
+                  << " ms ago); will resolve again in "
+                  << time_until_next_resolution.millis() << " ms";
       }
       ScheduleNextResolutionTimer(time_until_next_resolution);
       return;
@@ -260,11 +256,10 @@ void PollingResolver::StartResolvingLocked() {
   last_resolution_timestamp_ = Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     if (request_ != nullptr) {
-      gpr_log(GPR_INFO,
-              "[polling resolver %p] starting resolution, request_=%p", this,
-              request_.get());
+      LOG(INFO) << "[polling resolver " << this
+                << "] starting resolution, request_=" << request_.get();
     } else {
-      gpr_log(GPR_INFO, "[polling resolver %p] StartRequest failed", this);
+      LOG(INFO) << "[polling resolver " << this << "] StartRequest failed";
     }
   }
 }

data/src/core/resolver/resolver.cc

@@ -20,9 +20,6 @@
 
 #include <grpc/support/port_platform.h>
 
-grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
-                                                           "resolver_refcount");
-
 namespace grpc_core {
 
 //
@@ -30,8 +27,7 @@ namespace grpc_core {
 //
 
 Resolver::Resolver()
-    : InternallyRefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_trace_resolver_refcount)
-                               ? "Resolver"
-                               : nullptr) {}
+    : InternallyRefCounted(
+          GRPC_TRACE_FLAG_ENABLED(resolver_refcount) ? "Resolver" : nullptr) {}
 
 }  // namespace grpc_core

data/src/core/resolver/resolver.h

@@ -33,8 +33,6 @@
 #include "src/core/resolver/server_address.h"  // IWYU pragma: keep
 #include "src/core/service_config/service_config.h"
 
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
-
 // Name associated with individual address, if available.
 #define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
 

data/src/core/resolver/resolver_registry.cc

@@ -17,13 +17,13 @@
 #include "src/core/resolver/resolver_registry.h"
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {
@@ -147,15 +147,13 @@ ResolverFactory* ResolverRegistry::FindResolverFactory(
     return factory;
   }
   if (!tmp_uri.ok() || !tmp_uri2.ok()) {
-    gpr_log(GPR_ERROR, "%s",
-            absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
-                            tmp_uri.status().ToString(), *canonical_target,
-                            tmp_uri2.status().ToString())
-                .c_str());
+    LOG(ERROR) << "Error parsing URI(s). '" << target
+               << "':" << tmp_uri.status() << "; '" << *canonical_target
+               << "':" << tmp_uri2.status();
     return nullptr;
   }
-  gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
-          std::string(target).c_str(), canonical_target->c_str());
+  LOG(ERROR) << "Don't know how to resolve '" << target << "' or '"
+             << *canonical_target << "'.";
   return nullptr;
 }
 

data/src/core/resolver/sockaddr/sockaddr_resolver.cc

@@ -19,11 +19,11 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
@@ -76,8 +76,8 @@ bool ParseUri(const URI& uri,
               bool parse(const URI& uri, grpc_resolved_address* dst),
               EndpointAddressesList* addresses) {
   if (!uri.authority().empty()) {
-    gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
-            uri.scheme().c_str());
+    LOG(ERROR) << "authority-based URIs not supported by the " << uri.scheme()
+               << " scheme";
     return false;
   }
   // Construct addresses.