grpc 1.68.1 → 1.71.0

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -298,7 +298,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     if (details.size > 0) {
       error = absl::StrCat("Status ", code, " from handshaker service: ",
                            absl::string_view(details.data, details.size));
-      LOG(ERROR) << error;
+      LOG_EVERY_N_SEC(INFO, 1) << error;
     }
   }
   // TODO(apolcyn): consider short ciruiting handle_response_done and
@@ -744,7 +744,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
                 /*cq=*/nullptr, interested_parties,
                 grpc_core::Slice::FromStaticString(ALTS_SERVICE_METHOD),
-                /*authority=*/absl::nullopt, grpc_core::Timestamp::InfFuture(),
+                /*authority=*/std::nullopt, grpc_core::Timestamp::InfFuture(),
                 /*registered_method=*/true);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
@@ -930,7 +930,7 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
 
 size_t MaxNumberOfConcurrentHandshakes() {
   size_t max_concurrent_handshakes = 100;
-  absl::optional<std::string> env_var_max_concurrent_handshakes =
+  std::optional<std::string> env_var_max_concurrent_handshakes =
       grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
   if (env_var_max_concurrent_handshakes.has_value()) {
     size_t effective_max_concurrent_handshakes = 100;

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -347,22 +347,22 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     return TSI_FAILED_PRECONDITION;
   }
   if (grpc_gcp_Identity_attributes_size(identity) != 0) {
-    size_t iter = kUpb_Map_Begin;
-    grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
-        grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
-    while (peer_attributes_entry != nullptr) {
-      upb_StringView key = grpc_gcp_Identity_AttributesEntry_key(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      upb_StringView val = grpc_gcp_Identity_AttributesEntry_value(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
-                                               context_arena.ptr());
-      peer_attributes_entry =
-          grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
+    // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+    // v30.0.
+    const upb_Map* upb_map =
+        _grpc_gcp_Identity_attributes_upb_map(peer_identity);
+    if (upb_map) {
+      size_t iter = kUpb_Map_Begin;
+      upb_MessageValue k, v;
+      while (upb_Map_Next(upb_map, &k, &v, &iter)) {
+        upb_StringView key = k.str_val;
+        upb_StringView val = v.str_val;
+        grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
+                                                 context_arena.ptr());
+      }
     }
   }
+
   size_t serialized_ctx_length;
   char* serialized_ctx = grpc_gcp_AltsContext_serialize(
       context, context_arena.ptr(), &serialized_ctx_length);

data/src/core/tsi/alts/handshaker/transport_security_common_api.h

@@ -27,13 +27,13 @@
 #include "src/core/util/crash.h"
 #include "src/proto/grpc/gcp/transport_security_common.upb.h"
 
-// C struct coresponding to protobuf message RpcProtocolVersions.Version
+// C struct corresponding to protobuf message RpcProtocolVersions.Version
 typedef struct _grpc_gcp_RpcProtocolVersions_Version {
   uint32_t major;
   uint32_t minor;
 } grpc_gcp_rpc_protocol_versions_version;
 
-// C struct coresponding to protobuf message RpcProtocolVersions
+// C struct corresponding to protobuf message RpcProtocolVersions
 typedef struct _grpc_gcp_RpcProtocolVersions {
   grpc_gcp_rpc_protocol_versions_version max_rpc_version;
   grpc_gcp_rpc_protocol_versions_version min_rpc_version;

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -156,7 +156,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
   }
   alts_zero_copy_grpc_protector* protector =
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
-  // Calls alts_grpc_record_protocol protect repeatly.
+  // Calls alts_grpc_record_protocol protect repeatedly.
   while (unprotected_slices->length > protector->max_unprotected_data_size) {
     grpc_slice_buffer_move_first(unprotected_slices,
                                  protector->max_unprotected_data_size,

data/src/core/tsi/fake_transport_security.cc

@@ -191,6 +191,11 @@ static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
     frame->allocated_size = TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE;
     frame->data =
         static_cast<unsigned char*>(gpr_malloc(frame->allocated_size));
+    // Initialize `data` to some recognizably bad values.
+    // There's some debug code paths where we stringify the entire buffer, and
+    // doing so leads to ubsan failures on those code paths -- which are
+    // commonly hit using fuzzers.
+    memset(frame->data, 0xab, frame->allocated_size);
   }
 
   if (frame->offset < TSI_FAKE_FRAME_HEADER_SIZE) {

data/src/core/tsi/ssl_transport_security.cc

@@ -1656,11 +1656,18 @@ static tsi_result ssl_handshaker_do_handshake(tsi_ssl_handshaker* impl,
       default: {
         char err_str[256];
         ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
-        LOG(ERROR) << "Handshake failed with fatal error "
-                   << grpc_core::SslErrorString(ssl_result) << ": " << err_str;
+        long verify_result = SSL_get_verify_result(impl->ssl);
+        std::string verify_result_str;
+        if (verify_result != X509_V_OK) {
+          const char* verify_err = X509_verify_cert_error_string(verify_result);
+          verify_result_str = absl::StrCat(": ", verify_err);
+        }
+        LOG(INFO) << "Handshake failed with error "
+                  << grpc_core::SslErrorString(ssl_result) << ": " << err_str
+                  << verify_result_str;
         if (error != nullptr) {
           *error = absl::StrCat(grpc_core::SslErrorString(ssl_result), ": ",
-                                err_str);
+                                err_str, verify_result_str);
         }
         impl->result = TSI_PROTOCOL_FAILURE;
         return impl->result;
@@ -1710,7 +1717,7 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
-  // Atempt to read all of the bytes in SSL's read BIO. These bytes should
+  // Attempt to read all of the bytes in SSL's read BIO. These bytes should
   // contain application data records that were appended to a handshake record
   // containing the ClientFinished or ServerFinished message.
   size_t bytes_in_ssl = BIO_pending(SSL_get_rbio(impl->ssl));

data/src/core/tsi/ssl_transport_security.h

@@ -95,7 +95,7 @@ static constexpr bool tsi_tls_session_key_logging_supported() {
 // --- tsi_ssl_client_handshaker_factory object ---
 
 // This object creates a client tsi_handshaker objects implemented in terms of
-// the TLS 1.2 specificiation.
+// the TLS 1.2 specification.
 
 typedef struct tsi_ssl_client_handshaker_factory
     tsi_ssl_client_handshaker_factory;
@@ -243,7 +243,7 @@ void tsi_ssl_client_handshaker_factory_unref(
 // --- tsi_ssl_server_handshaker_factory object ---
 
 // This object creates a client tsi_handshaker objects implemented in terms of
-// the TLS 1.2 specificiation.
+// the TLS 1.2 specification.
 
 typedef struct tsi_ssl_server_handshaker_factory
     tsi_ssl_server_handshaker_factory;

data/src/core/tsi/ssl_transport_security_utils.h

@@ -97,7 +97,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
                                size_t* protected_output_frames_size);
 
 // Builds a TLS frame out of the remaining plaintext bytes that's left in
-// buffer. Populates the size of the remianing TLS frame to
+// buffer. Populates the size of the remaining TLS frame to
 // |still_pending_size|.
 //
 // buffer_size: the size of |buffer|. If |buffer_offset| equals |buffer_size|,

data/src/core/tsi/transport_security_interface.h

@@ -409,7 +409,7 @@ tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
 
 // TO BE DEPRECATED SOON.
 // Gets the result of the handshaker.
-// Returns TSI_OK if the hanshake completed successfully and there has been no
+// Returns TSI_OK if the handshake completed successfully and there has been no
 // errors. Returns TSI_HANDSHAKE_IN_PROGRESS if the handshaker is not done yet
 // but no error has been encountered so far. Otherwise the handshaker failed
 // with the returned error.
@@ -433,7 +433,7 @@ tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer);
 // is done. After this method has been called successfully, the only method
 // that can be called on this object is Destroy.
 // - max_output_protected_frame_size is an input/output parameter specifying the
-//   desired max output protected frame size as input and outputing the actual
+//   desired max output protected frame size as input and outputting the actual
 //   max output frame size as the output. Passing NULL is OK and will result in
 //   the implementation choosing the default maximum protected frame size. Note
 //   that this size only applies to outgoing frames (generated with

data/src/core/util/backoff.cc

@@ -22,16 +22,27 @@
 
 #include <algorithm>
 
+#include "src/core/lib/experiments/experiments.h"
+
 namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
 Duration BackOff::NextAttemptDelay() {
-  if (initial_) {
-    initial_ = false;
+  if (IsBackoffCapInitialAtMaxEnabled()) {
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ *= options_.multiplier();
+    }
+    current_backoff_ = std::min(current_backoff_, options_.max_backoff());
   } else {
-    current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
-                                options_.max_backoff());
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                                  options_.max_backoff());
+    }
   }
   const double jitter =
       absl::Uniform(rand_gen_, 1 - options_.jitter(), 1 + options_.jitter());

data/src/core/util/dump_args.h

@@ -26,20 +26,12 @@
 namespace grpc_core {
 namespace dump_args_detail {
 
-// Helper function... just ignore the initializer list passed into it.
-// Allows doing 'statements' via parameter pack expansion in C++11 - given
-// template <typename... Ts>:
-//  do_these_things({foo<Ts>()...});
-// will execute foo<T>() for each T in Ts.
-template <typename T>
-void do_these_things(std::initializer_list<T>) {}
-
 class DumpArgs {
  public:
   template <typename... Args>
   explicit DumpArgs(const char* arg_string, const Args&... args)
       : arg_string_(arg_string) {
-    do_these_things({AddDumper(&args)...});
+    (AddDumper(&args), ...);
   }
 
   template <typename Sink>

data/src/core/util/env.h

@@ -21,14 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 // Gets the environment variable value with the specified name. */
-absl::optional<std::string> GetEnv(const char* name);
+std::optional<std::string> GetEnv(const char* name);
 
 // Sets the environment with the specified name to the specified value.
 void SetEnv(const char* name, const char* value);
@@ -40,7 +39,7 @@ inline void SetEnv(const char* name, const std::string& value) {
 void UnsetEnv(const char* name);
 
 template <typename T>
-void SetOrUnsetEnv(const char* name, const absl::optional<T>& value) {
+void SetOrUnsetEnv(const char* name, const std::optional<T>& value) {
   if (value.has_value()) {
     SetEnv(name, value.value());
   } else {

data/src/core/util/examine_stack.cc

@@ -33,11 +33,11 @@ void SetCurrentStackTraceProvider(
   g_current_stack_trace_provider = current_stack_trace_provider;
 }
 
-absl::optional<std::string> GetCurrentStackTrace() {
+std::optional<std::string> GetCurrentStackTrace() {
   if (g_current_stack_trace_provider != nullptr) {
     return g_current_stack_trace_provider();
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/util/examine_stack.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 typedef std::string (*gpr_current_stack_trace_func)();
@@ -37,8 +36,8 @@ void SetCurrentStackTraceProvider(
     gpr_current_stack_trace_func current_stack_trace_provider);
 
 // Returns the current stack trace as a string via current_stack_trace_provider
-// If current_stack_trace_provider is not set, it returns absl::nullopt.
-absl::optional<std::string> GetCurrentStackTrace();
+// If current_stack_trace_provider is not set, it returns std::nullopt.
+std::optional<std::string> GetCurrentStackTrace();
 
 }  // namespace grpc_core
 

data/src/core/util/fork.cc

@@ -25,7 +25,7 @@
 
 #include <utility>
 
-#include "src/core/lib/config/config_vars.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/util/no_destruct.h"
 

data/src/core/util/fork.h

@@ -37,7 +37,7 @@ class GPR_DLL Fork {
 
   static void GlobalInit();
 
-  // Returns true if fork suppport is enabled, false otherwise
+  // Returns true if fork support is enabled, false otherwise
   static bool Enabled();
 
   // Increment the count of active ExecCtxs.
@@ -66,7 +66,7 @@ class GPR_DLL Fork {
   // Check if there is a single active ExecCtx
   // (the one used to invoke this function).  If there are more,
   // return false.  Otherwise, return true and block creation of
-  // more ExecCtx s until AlloWExecCtx() is called
+  // more ExecCtx s until AllowExecCtx() is called
   //
   static bool BlockExecCtx();
   static void AllowExecCtx();

data/src/core/util/gpr_time.cc

@@ -18,7 +18,6 @@
 
 // Generic implementation of time calls.
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 #include <limits.h>
@@ -26,7 +25,6 @@
 #include <string.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
@@ -224,7 +222,7 @@ int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold) {
 int32_t gpr_time_to_millis(gpr_timespec t) {
   if (t.tv_sec >= 2147483) {
     if (t.tv_sec == 2147483 && t.tv_nsec < 648 * GPR_NS_PER_MS) {
-      return 2147483 * GPR_MS_PER_SEC + t.tv_nsec / GPR_NS_PER_MS;
+      return (2147483 * GPR_MS_PER_SEC) + (t.tv_nsec / GPR_NS_PER_MS);
     }
     return 2147483647;
   } else if (t.tv_sec <= -2147483) {
@@ -232,13 +230,13 @@ int32_t gpr_time_to_millis(gpr_timespec t) {
     // care?)
     return -2147483647;
   } else {
-    return static_cast<int32_t>(t.tv_sec * GPR_MS_PER_SEC +
-                                t.tv_nsec / GPR_NS_PER_MS);
+    return static_cast<int32_t>((t.tv_sec * GPR_MS_PER_SEC) +
+                                (t.tv_nsec / GPR_NS_PER_MS));
   }
 }
 
 double gpr_timespec_to_micros(gpr_timespec t) {
-  return static_cast<double>(t.tv_sec) * GPR_US_PER_SEC + t.tv_nsec * 1e-3;
+  return (static_cast<double>(t.tv_sec) * GPR_US_PER_SEC) + (t.tv_nsec * 1e-3);
 }
 
 gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {

data/src/core/util/http_client/httpcli.cc

@@ -31,13 +31,14 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -55,6 +56,9 @@ namespace grpc_core {
 
 namespace {
 
+using grpc_event_engine::experimental::EventEngine;
+using grpc_event_engine::experimental::ResolvedAddressToURI;
+
 grpc_httpcli_get_override g_get_override;
 grpc_httpcli_post_override g_post_override;
 grpc_httpcli_put_override g_put_override;
@@ -67,7 +71,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_get_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -79,8 +83,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
   }
   std::string name =
       absl::StrFormat("HTTP:GET:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_get_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_get_request(request, uri.authority().c_str(),
+                                      uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -92,7 +97,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_post_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -103,8 +108,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
   }
   std::string name =
       absl::StrFormat("HTTP:POST:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_post_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_post_request(request, uri.authority().c_str(),
+                                       uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -116,7 +122,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_put_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -127,8 +133,9 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
   }
   std::string name =
       absl::StrFormat("HTTP:PUT:%s:%s", uri.authority(), uri.path());
-  const grpc_slice request_text = grpc_httpcli_format_put_request(
-      request, uri.authority().c_str(), uri.path().c_str());
+  const grpc_slice request_text =
+      grpc_httpcli_format_put_request(request, uri.authority().c_str(),
+                                      uri.EncodedPathAndQueryParams().c_str());
   return MakeOrphanable<HttpRequest>(
       std::move(uri), request_text, response, deadline, channel_args, on_done,
       pollent, name.c_str(), std::move(test_only_generate_response),
@@ -152,7 +159,7 @@ HttpRequest::HttpRequest(
     URI uri, const grpc_slice& request_text, grpc_http_response* response,
     Timestamp deadline, const grpc_channel_args* channel_args,
     grpc_closure* on_done, grpc_polling_entity* pollent, const char* name,
-    absl::optional<std::function<bool()>> test_only_generate_response,
+    std::optional<std::function<bool()>> test_only_generate_response,
     RefCountedPtr<grpc_channel_credentials> channel_creds)
     : uri_(std::move(uri)),
       request_text_(request_text),
@@ -168,7 +175,15 @@ HttpRequest::HttpRequest(
       pollent_(pollent),
       pollset_set_(grpc_pollset_set_create()),
       test_only_generate_response_(std::move(test_only_generate_response)),
-      resolver_(GetDNSResolver()) {
+      use_event_engine_dns_resolver_(IsEventEngineDnsNonClientChannelEnabled()),
+      resolver_(!use_event_engine_dns_resolver_ ? GetDNSResolver() : nullptr),
+      ee_resolver_(
+          use_event_engine_dns_resolver_
+              ? ChannelArgs::FromC(channel_args_)
+                    .GetObjectRef<EventEngine>()
+                    ->GetDNSResolver(
+                        EventEngine::DNSResolver::ResolverOptions())
+              : absl::InternalError("EventEngine DNS is not enabled")) {
   grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
   grpc_slice_buffer_init(&incoming_);
   grpc_slice_buffer_init(&outgoing_);
@@ -201,11 +216,38 @@ void HttpRequest::Start() {
   if (test_only_generate_response_.has_value()) {
     if (test_only_generate_response_.value()()) return;
   }
+  if (use_event_engine_dns_resolver_ && !ee_resolver_.ok()) {
+    Finish(ee_resolver_.status());
+    return;
+  }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_handle_ = resolver_->LookupHostname(
-      absl::bind_front(&HttpRequest::OnResolved, this), uri_.authority(),
-      uri_.scheme(), kDefaultDNSRequestTimeout, pollset_set_,
-      /*name_server=*/"");
+  if (use_event_engine_dns_resolver_) {
+    (*ee_resolver_)
+        ->LookupHostname(
+            [this](absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+                       addresses_or) {
+              ExecCtx exec_ctx;
+              OnResolved(addresses_or);
+            },
+            uri_.authority(), uri_.scheme());
+  } else {
+    dns_request_handle_ = resolver_->LookupHostname(
+        [this](absl::StatusOr<std::vector<grpc_resolved_address>> addresses) {
+          if (addresses.ok()) {
+            std::vector<EventEngine::ResolvedAddress> ee_addresses;
+            for (const auto& addr : *addresses) {
+              ee_addresses.push_back(
+                  grpc_event_engine::experimental::CreateResolvedAddress(addr));
+            }
+            OnResolved(ee_addresses);
+          } else {
+            OnResolved(addresses.status());
+          }
+        },
+        uri_.authority(), uri_.scheme(), kDefaultDNSRequestTimeout,
+        pollset_set_,
+        /*name_server=*/"");
+  }
 }
 
 void HttpRequest::Orphan() {
@@ -214,10 +256,16 @@ void HttpRequest::Orphan() {
     CHECK(!cancelled_);
     cancelled_ = true;
     // cancel potentially pending DNS resolution.
-    if (dns_request_handle_.has_value() &&
-        resolver_->Cancel(dns_request_handle_.value())) {
-      Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
-      Unref();
+    if (use_event_engine_dns_resolver_) {
+      if (*ee_resolver_ != nullptr) {
+        ee_resolver_->reset();
+      }
+    } else {
+      if (dns_request_handle_.has_value() &&
+          resolver_->Cancel(dns_request_handle_.value())) {
+        Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
+        Unref();
+      }
     }
     if (handshake_mgr_ != nullptr) {
       // Shutdown will cancel any ongoing tcp connect.
@@ -233,14 +281,15 @@ void HttpRequest::AppendError(grpc_error_handle error) {
   if (overall_error_.ok()) {
     overall_error_ = GRPC_ERROR_CREATE("Failed HTTP/1 client request");
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
-  auto addr_text = grpc_sockaddr_to_uri(addr);
+  auto addr_text = ResolvedAddressToURI(addresses_[next_address_ - 1]);
   if (addr_text.ok()) error = AddMessagePrefix(*addr_text, std::move(error));
   overall_error_ = grpc_error_add_child(overall_error_, std::move(error));
 }
 
 void HttpRequest::OnReadInternal(grpc_error_handle error) {
   for (size_t i = 0; i < incoming_.count; i++) {
+    GRPC_TRACE_LOG(http1, INFO)
+        << "HTTP response data: " << StringViewFromSlice(incoming_.slices[i]);
     if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
       have_read_byte_ = 1;
       grpc_error_handle err =
@@ -275,6 +324,8 @@ void HttpRequest::ContinueDoneWriteAfterScheduleOnExecCtx(
 }
 
 void HttpRequest::StartWrite() {
+  GRPC_TRACE_LOG(http1, INFO)
+      << "Sending HTTP1 request: " << StringViewFromSlice(request_text_);
   CSliceRef(request_text_);
   grpc_slice_buffer_add(&outgoing_, request_text_);
   Ref().release();  // ref held by pending write
@@ -304,7 +355,7 @@ void HttpRequest::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
   StartWrite();
 }
 
-void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
+void HttpRequest::DoHandshake(const EventEngine::ResolvedAddress& addr) {
   // Create the security connector using the credentials and target name.
   ChannelArgs args = ChannelArgs::FromC(channel_args_);
   RefCountedPtr<grpc_channel_security_connector> sc =
@@ -315,7 +366,7 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
                                          &overall_error_, 1));
     return;
   }
-  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(addr);
+  absl::StatusOr<std::string> address = ResolvedAddressToURI(addr);
   if (!address.ok()) {
     Finish(GRPC_ERROR_CREATE_REFERENCING("Failed to extract URI from address",
                                          &overall_error_, 1));
@@ -348,15 +399,18 @@ void HttpRequest::NextAddress(grpc_error_handle error) {
                                          &overall_error_, 1));
     return;
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_++];
-  DoHandshake(addr);
+  DoHandshake(addresses_[next_address_++]);
 }
 
 void HttpRequest::OnResolved(
-    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+    absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses_or) {
   RefCountedPtr<HttpRequest> unreffer(this);
   MutexLock lock(&mu_);
-  dns_request_handle_.reset();
+  if (use_event_engine_dns_resolver_) {
+    ee_resolver_->reset();
+  } else {
+    dns_request_handle_.reset();
+  }
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
     return;