grpc 1.60.0 → 1.62.0

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

@@ -42,19 +42,55 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(yashykt): This filter is not really needed. We should be able to move
-// this to the connected filter.
-class ServerCallTracerFilter : public ChannelFilter {
+class ServerCallTracerFilter
+    : public ImplementChannelFilter<ServerCallTracerFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<ServerCallTracerFilter> Create(
       const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/);
 
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& client_initial_metadata) {
+      auto* call_tracer = CallTracer();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordReceivedInitialMetadata(&client_initial_metadata);
+    }
+
+    void OnServerInitialMetadata(ServerMetadata& server_initial_metadata) {
+      auto* call_tracer = CallTracer();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordSendInitialMetadata(&server_initial_metadata);
+    }
+
+    void OnFinalize(const grpc_call_final_info* final_info) {
+      auto* call_tracer = CallTracer();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordEnd(final_info);
+    }
+
+    void OnServerTrailingMetadata(ServerMetadata& server_trailing_metadata) {
+      auto* call_tracer = CallTracer();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
+    }
+
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+
+   private:
+    static ServerCallTracer* CallTracer() {
+      auto* call_context = GetContext<grpc_call_context_element>();
+      return static_cast<ServerCallTracer*>(
+          call_context[GRPC_CONTEXT_CALL_TRACER].value);
+    }
+  };
 };
 
+const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerMessage;
+const NoInterceptor ServerCallTracerFilter::Call::OnServerToClientMessage;
+
 const grpc_channel_filter ServerCallTracerFilter::kFilter =
     MakePromiseBasedFilter<ServerCallTracerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>(
@@ -65,39 +101,11 @@ absl::StatusOr<ServerCallTracerFilter> ServerCallTracerFilter::Create(
   return ServerCallTracerFilter();
 }
 
-ArenaPromise<ServerMetadataHandle> ServerCallTracerFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto* call_context = GetContext<grpc_call_context_element>();
-  auto* call_tracer = static_cast<ServerCallTracer*>(
-      call_context[GRPC_CONTEXT_CALL_TRACER].value);
-  if (call_tracer == nullptr) {
-    return next_promise_factory(std::move(call_args));
-  }
-  call_tracer->RecordReceivedInitialMetadata(
-      call_args.client_initial_metadata.get());
-  call_args.server_initial_metadata->InterceptAndMap(
-      [call_tracer](ServerMetadataHandle metadata) {
-        call_tracer->RecordSendInitialMetadata(metadata.get());
-        return metadata;
-      });
-  GetContext<CallFinalization>()->Add(
-      [call_tracer](const grpc_call_final_info* final_info) {
-        call_tracer->RecordEnd(final_info);
-      });
-  return OnCancel(
-      Map(next_promise_factory(std::move(call_args)),
-          [call_tracer](ServerMetadataHandle md) {
-            call_tracer->RecordSendTrailingMetadata(md.get());
-            return md;
-          }),
-      [call_tracer]() { call_tracer->RecordCancel(absl::CancelledError()); });
-}
-
 }  // namespace
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterFilter(GRPC_SERVER_CHANNEL,
-                                          &ServerCallTracerFilter::kFilter);
+  builder->channel_init()->RegisterFilter<ServerCallTracerFilter>(
+      GRPC_SERVER_CHANNEL);
 }
 
 }  // namespace grpc_core

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

@@ -36,7 +36,6 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/ref_counted_string.h"
-#include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
 
@@ -112,8 +111,6 @@ absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
 grpc_compression_algorithm
 CompressionAlgorithmSet::CompressionAlgorithmForLevel(
     grpc_compression_level level) const {
-  GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1,
-                 ((int)level));
   if (level > GRPC_COMPRESS_LEVEL_HIGH) {
     Crash(absl::StrFormat("Unknown message compression level %d.",
                           static_cast<int>(level)));

data/src/core/lib/config/core_configuration.h

@@ -25,13 +25,13 @@
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/handshaker/proxy_mapper_registry.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
-#include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/resolver/resolver_registry.h"
+#include "src/core/service_config/service_config_parser.h"
 
 namespace grpc_core {
 

data/src/core/lib/event_engine/ares_resolver.cc

@@ -32,6 +32,7 @@
 
 #if GRPC_ARES == 1
 
+#include <address_sorting/address_sorting.h>
 #include <ares.h>
 
 #if ARES_VERSION >= 0x011200
@@ -144,6 +145,28 @@ absl::Status SetRequestDNSServer(absl::string_view dns_server,
   return absl::OkStatus();
 }
 
+std::vector<EventEngine::ResolvedAddress> SortAddresses(
+    const std::vector<EventEngine::ResolvedAddress>& addresses) {
+  address_sorting_sortable* sortables = static_cast<address_sorting_sortable*>(
+      gpr_zalloc(sizeof(address_sorting_sortable) * addresses.size()));
+  for (size_t i = 0; i < addresses.size(); i++) {
+    sortables[i].user_data =
+        const_cast<EventEngine::ResolvedAddress*>(&addresses[i]);
+    memcpy(&sortables[i].dest_addr.addr, addresses[i].address(),
+           addresses[i].size());
+    sortables[i].dest_addr.len = addresses[i].size();
+  }
+  address_sorting_rfc_6724_sort(sortables, addresses.size());
+  std::vector<EventEngine::ResolvedAddress> sorted_addresses;
+  sorted_addresses.reserve(addresses.size());
+  for (size_t i = 0; i < addresses.size(); ++i) {
+    sorted_addresses.emplace_back(
+        *static_cast<EventEngine::ResolvedAddress*>(sortables[i].user_data));
+  }
+  gpr_free(sortables);
+  return sorted_addresses;
+}
+
 struct QueryArg {
   QueryArg(AresResolver* ar, int id, absl::string_view name)
       : ares_resolver(ar), callback_map_id(id), query_name(name) {}
@@ -156,6 +179,9 @@ struct HostnameQueryArg : public QueryArg {
   HostnameQueryArg(AresResolver* ar, int id, absl::string_view name, int p)
       : QueryArg(ar, id, name), port(p) {}
   int port;
+  int pending_requests;
+  absl::Status error_status;
+  std::vector<EventEngine::ResolvedAddress> result;
 };
 
 }  // namespace
@@ -193,7 +219,7 @@ AresResolver::CreateAresResolver(
 AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
     std::shared_ptr<EventEngine> event_engine, ares_channel channel)
-    : grpc_core::InternallyRefCounted<AresResolver>(
+    : RefCountedDNSResolverInterface(
           GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver) ? "AresResolver"
                                                             : nullptr),
       channel_(channel),
@@ -230,8 +256,8 @@ void AresResolver::Orphan() {
 }
 
 void AresResolver::LookupHostname(
-    absl::string_view name, absl::string_view default_port,
-    EventEngine::DNSResolver::LookupHostnameCallback callback) {
+    EventEngine::DNSResolver::LookupHostnameCallback callback,
+    absl::string_view name, absl::string_view default_port) {
   absl::string_view host;
   absl::string_view port_string;
   if (!grpc_core::SplitHostPort(name, &host, &port_string)) {
@@ -241,7 +267,13 @@ void AresResolver::LookupHostname(
              "Unparseable name: ", name))]() mutable { callback(status); });
     return;
   }
-  GPR_ASSERT(!host.empty());
+  if (host.empty()) {
+    event_engine_->Run([callback = std::move(callback),
+                        status = absl::InvalidArgumentError(absl::StrCat(
+                            "host must not be empty in name: ",
+                            name))]() mutable { callback(status); });
+    return;
+  }
   if (port_string.empty()) {
     if (default_port.empty()) {
       event_engine_->Run([callback = std::move(callback),
@@ -285,9 +317,16 @@ void AresResolver::LookupHostname(
   callback_map_.emplace(++id_, std::move(callback));
   auto* resolver_arg = new HostnameQueryArg(this, id_, name, port);
   if (IsIpv6LoopbackAvailable()) {
-    ares_gethostbyname(channel_, std::string(host).c_str(), AF_UNSPEC,
+    // Note that using AF_UNSPEC for both IPv6 and IPv4 queries does not work in
+    // all cases, e.g. for localhost:<> it only gets back the IPv6 result (i.e.
+    // ::1).
+    resolver_arg->pending_requests = 2;
+    ares_gethostbyname(channel_, std::string(host).c_str(), AF_INET,
+                       &AresResolver::OnHostbynameDoneLocked, resolver_arg);
+    ares_gethostbyname(channel_, std::string(host).c_str(), AF_INET6,
                        &AresResolver::OnHostbynameDoneLocked, resolver_arg);
   } else {
+    resolver_arg->pending_requests = 1;
     ares_gethostbyname(channel_, std::string(host).c_str(), AF_INET,
                        &AresResolver::OnHostbynameDoneLocked, resolver_arg);
   }
@@ -296,8 +335,8 @@ void AresResolver::LookupHostname(
 }
 
 void AresResolver::LookupSRV(
-    absl::string_view name,
-    EventEngine::DNSResolver::LookupSRVCallback callback) {
+    EventEngine::DNSResolver::LookupSRVCallback callback,
+    absl::string_view name) {
   absl::string_view host;
   absl::string_view port;
   if (!grpc_core::SplitHostPort(name, &host, &port)) {
@@ -307,7 +346,13 @@ void AresResolver::LookupSRV(
              "Unparseable name: ", name))]() mutable { callback(status); });
     return;
   }
-  GPR_ASSERT(!host.empty());
+  if (host.empty()) {
+    event_engine_->Run([callback = std::move(callback),
+                        status = absl::InvalidArgumentError(absl::StrCat(
+                            "host must not be empty in name: ",
+                            name))]() mutable { callback(status); });
+    return;
+  }
   // Don't query for SRV records if the target is "localhost"
   if (absl::EqualsIgnoreCase(host, "localhost")) {
     event_engine_->Run([callback = std::move(callback)]() mutable {
@@ -325,8 +370,8 @@ void AresResolver::LookupSRV(
 }
 
 void AresResolver::LookupTXT(
-    absl::string_view name,
-    EventEngine::DNSResolver::LookupTXTCallback callback) {
+    EventEngine::DNSResolver::LookupTXTCallback callback,
+    absl::string_view name) {
   absl::string_view host;
   absl::string_view port;
   if (!grpc_core::SplitHostPort(name, &host, &port)) {
@@ -336,7 +381,13 @@ void AresResolver::LookupTXT(
              "Unparseable name: ", name))]() mutable { callback(status); });
     return;
   }
-  GPR_ASSERT(!host.empty());
+  if (host.empty()) {
+    event_engine_->Run([callback = std::move(callback),
+                        status = absl::InvalidArgumentError(absl::StrCat(
+                            "host must not be empty in name: ",
+                            name))]() mutable { callback(status); });
+    return;
+  }
   // Don't query for TXT records if the target is "localhost"
   if (absl::EqualsIgnoreCase(host, "localhost")) {
     event_engine_->Run([callback = std::move(callback)]() mutable {
@@ -387,7 +438,8 @@ void AresResolver::CheckSocketsLocked() {
             event_engine_->Run(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node]() mutable {
-                  self->OnReadable(fd_node, absl::OkStatus());
+                  static_cast<AresResolver*>(self.get())
+                      ->OnReadable(fd_node, absl::OkStatus());
                 });
           } else {
             // Otherwise register with the poller for readable event.
@@ -396,7 +448,8 @@ void AresResolver::CheckSocketsLocked() {
             fd_node->polled_fd->RegisterForOnReadableLocked(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node](absl::Status status) mutable {
-                  self->OnReadable(fd_node, status);
+                  static_cast<AresResolver*>(self.get())
+                      ->OnReadable(fd_node, status);
                 });
           }
         }
@@ -410,7 +463,8 @@ void AresResolver::CheckSocketsLocked() {
           fd_node->polled_fd->RegisterForOnWriteableLocked(
               [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                fd_node](absl::Status status) mutable {
-                self->OnWritable(fd_node, status);
+                static_cast<AresResolver*>(self.get())
+                    ->OnWritable(fd_node, status);
               });
         }
       }
@@ -453,7 +507,7 @@ void AresResolver::MaybeStartTimerLocked() {
   ares_backup_poll_alarm_handle_ = event_engine_->RunAfter(
       kAresBackupPollAlarmDuration,
       [self = Ref(DEBUG_LOCATION, "MaybeStartTimerLocked")]() {
-        self->OnAresBackupPollAlarm();
+        static_cast<AresResolver*>(self.get())->OnAresBackupPollAlarm();
       });
 }
 
@@ -527,74 +581,88 @@ void AresResolver::OnAresBackupPollAlarm() {
 void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
                                           int /*timeouts*/,
                                           struct hostent* hostent) {
-  std::unique_ptr<HostnameQueryArg> hostname_qa(
-      static_cast<HostnameQueryArg*>(arg));
+  auto* hostname_qa = static_cast<HostnameQueryArg*>(arg);
+  GPR_ASSERT(hostname_qa->pending_requests-- > 0);
   auto* ares_resolver = hostname_qa->ares_resolver;
-  auto nh = ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
-  GPR_ASSERT(!nh.empty());
-  GPR_ASSERT(
-      absl::holds_alternative<EventEngine::DNSResolver::LookupHostnameCallback>(
-          nh.mapped()));
-  auto callback = absl::get<EventEngine::DNSResolver::LookupHostnameCallback>(
-      std::move(nh.mapped()));
   if (status != ARES_SUCCESS) {
     std::string error_msg =
         absl::StrFormat("address lookup failed for %s: %s",
                         hostname_qa->query_name, ares_strerror(status));
     GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p OnHostbynameDoneLocked: %s",
                                  ares_resolver, error_msg.c_str());
-    ares_resolver->event_engine_->Run(
-        [callback = std::move(callback),
-         status = AresStatusToAbslStatus(status, error_msg)]() mutable {
-          callback(status);
-        });
-    return;
-  }
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "resolver:%p OnHostbynameDoneLocked name=%s ARES_SUCCESS", ares_resolver,
-      hostname_qa->query_name.c_str());
-  std::vector<EventEngine::ResolvedAddress> result;
-  for (size_t i = 0; hostent->h_addr_list[i] != nullptr; i++) {
-    switch (hostent->h_addrtype) {
-      case AF_INET6: {
-        size_t addr_len = sizeof(struct sockaddr_in6);
-        struct sockaddr_in6 addr;
-        memset(&addr, 0, addr_len);
-        memcpy(&addr.sin6_addr, hostent->h_addr_list[i],
-               sizeof(struct in6_addr));
-        addr.sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
-        addr.sin6_port = htons(hostname_qa->port);
-        result.emplace_back(reinterpret_cast<const sockaddr*>(&addr), addr_len);
-        char output[INET6_ADDRSTRLEN];
-        ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "resolver:%p c-ares resolver gets a AF_INET6 result: \n"
-            "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
-            ares_resolver, output, hostname_qa->port, addr.sin6_scope_id);
-        break;
-      }
-      case AF_INET: {
-        size_t addr_len = sizeof(struct sockaddr_in);
-        struct sockaddr_in addr;
-        memset(&addr, 0, addr_len);
-        memcpy(&addr.sin_addr, hostent->h_addr_list[i], sizeof(struct in_addr));
-        addr.sin_family = static_cast<unsigned char>(hostent->h_addrtype);
-        addr.sin_port = htons(hostname_qa->port);
-        result.emplace_back(reinterpret_cast<const sockaddr*>(&addr), addr_len);
-        char output[INET_ADDRSTRLEN];
-        ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "resolver:%p c-ares resolver gets a AF_INET result: \n"
-            "  addr: %s\n  port: %d\n",
-            ares_resolver, output, hostname_qa->port);
-        break;
+    hostname_qa->error_status = AresStatusToAbslStatus(status, error_msg);
+  } else {
+    GRPC_ARES_RESOLVER_TRACE_LOG(
+        "resolver:%p OnHostbynameDoneLocked name=%s ARES_SUCCESS",
+        ares_resolver, hostname_qa->query_name.c_str());
+    for (size_t i = 0; hostent->h_addr_list[i] != nullptr; i++) {
+      switch (hostent->h_addrtype) {
+        case AF_INET6: {
+          size_t addr_len = sizeof(struct sockaddr_in6);
+          struct sockaddr_in6 addr;
+          memset(&addr, 0, addr_len);
+          memcpy(&addr.sin6_addr, hostent->h_addr_list[i],
+                 sizeof(struct in6_addr));
+          addr.sin6_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr.sin6_port = htons(hostname_qa->port);
+          hostname_qa->result.emplace_back(
+              reinterpret_cast<const sockaddr*>(&addr), addr_len);
+          char output[INET6_ADDRSTRLEN];
+          ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
+          GRPC_ARES_RESOLVER_TRACE_LOG(
+              "resolver:%p c-ares resolver gets a AF_INET6 result: \n"
+              "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
+              ares_resolver, output, hostname_qa->port, addr.sin6_scope_id);
+          break;
+        }
+        case AF_INET: {
+          size_t addr_len = sizeof(struct sockaddr_in);
+          struct sockaddr_in addr;
+          memset(&addr, 0, addr_len);
+          memcpy(&addr.sin_addr, hostent->h_addr_list[i],
+                 sizeof(struct in_addr));
+          addr.sin_family = static_cast<unsigned char>(hostent->h_addrtype);
+          addr.sin_port = htons(hostname_qa->port);
+          hostname_qa->result.emplace_back(
+              reinterpret_cast<const sockaddr*>(&addr), addr_len);
+          char output[INET_ADDRSTRLEN];
+          ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
+          GRPC_ARES_RESOLVER_TRACE_LOG(
+              "resolver:%p c-ares resolver gets a AF_INET result: \n"
+              "  addr: %s\n  port: %d\n",
+              ares_resolver, output, hostname_qa->port);
+          break;
+        }
+        default:
+          grpc_core::Crash(
+              absl::StrFormat("resolver:%p Received invalid type of address %d",
+                              ares_resolver, hostent->h_addrtype));
       }
     }
   }
-  ares_resolver->event_engine_->Run(
-      [callback = std::move(callback), result = std::move(result)]() mutable {
-        callback(std::move(result));
-      });
+  if (hostname_qa->pending_requests == 0) {
+    auto nh =
+        ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
+    GPR_ASSERT(!nh.empty());
+    GPR_ASSERT(absl::holds_alternative<
+               EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
+    auto callback = absl::get<EventEngine::DNSResolver::LookupHostnameCallback>(
+        std::move(nh.mapped()));
+    if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
+      ares_resolver->event_engine_->Run(
+          [callback = std::move(callback),
+           result = SortAddresses(hostname_qa->result)]() mutable {
+            callback(std::move(result));
+          });
+    } else {
+      ares_resolver->event_engine_->Run(
+          [callback = std::move(callback),
+           result = std::move(hostname_qa->error_status)]() mutable {
+            callback(std::move(result));
+          });
+    }
+    delete hostname_qa;
+  }
 }
 
 void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,

data/src/core/lib/event_engine/ares_resolver.h

@@ -39,6 +39,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
+#include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 
@@ -54,7 +55,7 @@ extern grpc_core::TraceFlag grpc_trace_ares_resolver;
     }                                                                          \
   } while (0)
 
-class AresResolver : public grpc_core::InternallyRefCounted<AresResolver> {
+class AresResolver : public RefCountedDNSResolverInterface {
  public:
   static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
   CreateAresResolver(absl::string_view dns_server,
@@ -67,15 +68,13 @@ class AresResolver : public grpc_core::InternallyRefCounted<AresResolver> {
   ~AresResolver() override;
   void Orphan() override ABSL_LOCKS_EXCLUDED(mutex_);
 
-  void LookupHostname(absl::string_view name, absl::string_view default_port,
-                      EventEngine::DNSResolver::LookupHostnameCallback callback)
-      ABSL_LOCKS_EXCLUDED(mutex_);
-  void LookupSRV(absl::string_view name,
-                 EventEngine::DNSResolver::LookupSRVCallback callback)
-      ABSL_LOCKS_EXCLUDED(mutex_);
-  void LookupTXT(absl::string_view name,
-                 EventEngine::DNSResolver::LookupTXTCallback callback)
-      ABSL_LOCKS_EXCLUDED(mutex_);
+  void LookupHostname(EventEngine::DNSResolver::LookupHostnameCallback callback,
+                      absl::string_view name, absl::string_view default_port)
+      ABSL_LOCKS_EXCLUDED(mutex_) override;
+  void LookupSRV(EventEngine::DNSResolver::LookupSRVCallback callback,
+                 absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
+  void LookupTXT(EventEngine::DNSResolver::LookupTXTCallback callback,
+                 absl::string_view name) ABSL_LOCKS_EXCLUDED(mutex_) override;
 
  private:
   // A FdNode saves (not owns) a live socket/fd which c-ares creates, and owns a

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -18,6 +18,10 @@
 #include <AvailabilityMacros.h>
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
 #include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/strerror.h"

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -50,7 +50,14 @@ void DNSServiceResolverImpl::LookupHostname(
     });
     return;
   }
-  GPR_ASSERT(!host.empty());
+  if (host.empty()) {
+    engine_->Run([on_resolve = std::move(on_resolve),
+                  status = absl::InvalidArgumentError(absl::StrCat(
+                      "host must not be empty in name: ", name))]() mutable {
+      on_resolve(status);
+    });
+    return;
+  }
   if (port_string.empty()) {
     if (default_port.empty()) {
       engine_->Run([on_resolve = std::move(on_resolve),

data/src/core/lib/event_engine/extensions/can_track_errors.h

@@ -0,0 +1,40 @@
+// Copyright 2024 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class EndpointCanTrackErrorsExtension {
+ public:
+  virtual ~EndpointCanTrackErrorsExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.can_track_errors";
+  }
+
+  /// Returns if the Endpoint supports tracking events from errmsg queues on
+  /// posix systems.
+  virtual bool CanTrackErrors() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H