grpc 1.65.2 → 1.66.0.pre3

data/src/core/tsi/ssl_transport_security.cc

@@ -206,7 +206,7 @@ static void init_openssl(void) {
     CRYPTO_set_locking_callback(openssl_locking_cb);
     CRYPTO_set_id_callback(openssl_thread_id_cb);
   } else {
-    LOG(INFO) << "OpenSSL callback has already been set.";
+    GRPC_TRACE_LOG(tsi, INFO) << "OpenSSL callback has already been set.";
   }
 #endif
   g_ssl_ctx_ex_factory_index =
@@ -228,8 +228,9 @@ static void init_openssl(void) {
 static void ssl_log_where_info(const SSL* ssl, int where, int flag,
                                const char* msg) {
   if ((where & flag) && GRPC_TRACE_FLAG_ENABLED(tsi)) {
-    gpr_log(GPR_INFO, "%20.20s - %30.30s  - %5.10s", msg,
-            SSL_state_string_long(ssl), SSL_state_string(ssl));
+    LOG(INFO) << absl::StrFormat("%20.20s - %s  - %s", msg,
+                                 SSL_state_string_long(ssl),
+                                 SSL_state_string(ssl));
   }
 }
 
@@ -336,7 +337,7 @@ static tsi_result peer_property_from_x509_subject(X509* cert,
                                                   bool is_verified_root_cert) {
   X509_NAME* subject_name = X509_get_subject_name(cert);
   if (subject_name == nullptr) {
-    LOG(INFO) << "Could not get subject name from certificate.";
+    GRPC_TRACE_LOG(tsi, INFO) << "Could not get subject name from certificate.";
     return TSI_NOT_FOUND;
   }
   BIO* bio = BIO_new(BIO_s_mem());
@@ -892,8 +893,9 @@ static tsi_result build_alpn_protocol_name_list(
 static int verify_cb(int ok, X509_STORE_CTX* ctx) {
   int cert_error = X509_STORE_CTX_get_error(ctx);
   if (cert_error == X509_V_ERR_UNABLE_TO_GET_CRL) {
-    LOG(INFO) << "Certificate verification failed to find relevant CRL file. "
-                 "Ignoring error.";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "Certificate verification failed to find relevant CRL file. "
+           "Ignoring error.";
     return 1;
   }
   if (cert_error != 0) {
@@ -960,7 +962,8 @@ static int RootCertExtractCallback(X509_STORE_CTX* ctx, void* /*arg*/) {
   int success =
       SSL_set_ex_data(ssl, g_ssl_ex_verified_root_cert_index, root_cert);
   if (success == 0) {
-    LOG(INFO) << "Could not set verified root cert in SSL's ex_data";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "Could not set verified root cert in SSL's ex_data";
   } else {
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
     X509_up_ref(root_cert);
@@ -978,15 +981,16 @@ static grpc_core::experimental::CrlProvider* GetCrlProvider(
   if (ssl_index < 0) {
     char err_str[256];
     ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
-    gpr_log(GPR_INFO,
-            "error getting the SSL index from the X509_STORE_CTX while looking "
-            "up Crl: %s",
-            err_str);
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "error getting the SSL index from the X509_STORE_CTX while looking "
+           "up Crl: "
+        << err_str;
     return nullptr;
   }
   SSL* ssl = static_cast<SSL*>(X509_STORE_CTX_get_ex_data(ctx, ssl_index));
   if (ssl == nullptr) {
-    LOG(INFO) << "error while fetching from CrlProvider. SSL object is null";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "error while fetching from CrlProvider. SSL object is null";
     return nullptr;
   }
   SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1004,13 +1008,14 @@ static absl::StatusOr<X509_CRL*> GetCrlFromProvider(
   }
   absl::StatusOr<std::string> issuer_name = grpc_core::IssuerFromCert(cert);
   if (!issuer_name.ok()) {
-    LOG(INFO) << "Could not get certificate issuer name";
+    GRPC_TRACE_LOG(tsi, INFO) << "Could not get certificate issuer name";
     return absl::InvalidArgumentError(issuer_name.status().message());
   }
   absl::StatusOr<std::string> akid = grpc_core::AkidFromCertificate(cert);
   std::string akid_to_use;
   if (!akid.ok()) {
-    LOG(INFO) << "Could not get certificate authority key identifier.";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "Could not get certificate authority key identifier.";
   } else {
     akid_to_use = *akid;
   }
@@ -1173,8 +1178,8 @@ static tsi_result tsi_set_min_and_max_tls_versions(
     SSL_CTX* ssl_context, tsi_tls_version min_tls_version,
     tsi_tls_version max_tls_version) {
   if (ssl_context == nullptr) {
-    LOG(INFO) << "Invalid nullptr argument to "
-                 "|tsi_set_min_and_max_tls_versions|.";
+    GRPC_TRACE_LOG(tsi, INFO) << "Invalid nullptr argument to "
+                                 "|tsi_set_min_and_max_tls_versions|.";
     return TSI_INVALID_ARGUMENT;
   }
 #if OPENSSL_VERSION_NUMBER >= 0x10100000
@@ -1195,7 +1200,7 @@ static tsi_result tsi_set_min_and_max_tls_versions(
       break;
 #endif
     default:
-      LOG(INFO) << "TLS version is not supported.";
+      GRPC_TRACE_LOG(tsi, INFO) << "TLS version is not supported.";
       return TSI_FAILED_PRECONDITION;
   }
 
@@ -1214,7 +1219,7 @@ static tsi_result tsi_set_min_and_max_tls_versions(
 #endif
       break;
     default:
-      LOG(INFO) << "TLS version is not supported.";
+      GRPC_TRACE_LOG(tsi, INFO) << "TLS version is not supported.";
       return TSI_FAILED_PRECONDITION;
   }
 #endif
@@ -1519,8 +1524,7 @@ static tsi_result ssl_handshaker_result_create_frame_protector(
   protector_impl->buffer =
       static_cast<unsigned char*>(gpr_malloc(protector_impl->buffer_size));
   if (protector_impl->buffer == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Could not allocated buffer for tsi_ssl_frame_protector.");
+    LOG(ERROR) << "Could not allocate buffer for tsi_ssl_frame_protector.";
     gpr_free(protector_impl);
     return TSI_INTERNAL_ERROR;
   }
@@ -1647,8 +1651,8 @@ 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));
-        gpr_log(GPR_ERROR, "Handshake failed with fatal error %s: %s.",
-                grpc_core::SslErrorString(ssl_result), err_str);
+        LOG(ERROR) << "Handshake failed with fatal error "
+                   << grpc_core::SslErrorString(ssl_result) << ": " << err_str;
         if (error != nullptr) {
           *error = absl::StrCat(grpc_core::SslErrorString(ssl_result), ": ",
                                 err_str);
@@ -1712,8 +1716,8 @@ static tsi_result ssl_bytes_remaining(tsi_ssl_handshaker* impl,
   // If an unexpected number of bytes were read, return an error status and
   // free all of the bytes that were read.
   if (bytes_read < 0 || static_cast<size_t>(bytes_read) != bytes_in_ssl) {
-    gpr_log(GPR_ERROR,
-            "Failed to read the expected number of bytes from SSL object.");
+    LOG(ERROR)
+        << "Failed to read the expected number of bytes from SSL object.";
     gpr_free(*bytes_remaining);
     *bytes_remaining = nullptr;
     if (error != nullptr) {
@@ -1830,6 +1834,17 @@ static tsi_result ssl_handshaker_next(tsi_handshaker* self,
       // Indicates that the handshake has completed and that a
       // handshaker_result has been created.
       self->handshaker_result_created = true;
+      // Output Cipher information
+      if (GRPC_TRACE_FLAG_ENABLED(tsi)) {
+        tsi_ssl_handshaker_result* result =
+            reinterpret_cast<tsi_ssl_handshaker_result*>(*handshaker_result);
+        auto cipher = SSL_get_current_cipher(result->ssl);
+        if (cipher != nullptr) {
+          GRPC_TRACE_LOG(tsi, INFO) << absl::StrFormat(
+              "SSL Cipher Version: %s Name: %s", SSL_CIPHER_get_version(cipher),
+              SSL_CIPHER_get_name(cipher));
+        }
+      }
     }
   }
   return status;
@@ -1896,8 +1911,8 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
     if (server_name_indication != nullptr &&
         !looks_like_ip_address(server_name_indication)) {
       if (!SSL_set_tlsext_host_name(ssl, server_name_indication)) {
-        gpr_log(GPR_ERROR, "Invalid server name indication %s.",
-                server_name_indication);
+        LOG(ERROR) << "Invalid server name indication "
+                   << server_name_indication;
         SSL_free(ssl);
         BIO_free(network_io);
         return TSI_INTERNAL_ERROR;
@@ -1913,9 +1928,9 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
     ssl_result = SSL_do_handshake(ssl);
     ssl_result = SSL_get_error(ssl, ssl_result);
     if (ssl_result != SSL_ERROR_WANT_READ) {
-      gpr_log(GPR_ERROR,
-              "Unexpected error received from first SSL_do_handshake call: %s",
-              grpc_core::SslErrorString(ssl_result));
+      LOG(ERROR)
+          << "Unexpected error received from first SSL_do_handshake call: "
+          << grpc_core::SslErrorString(ssl_result);
       SSL_free(ssl);
       BIO_free(network_io);
       return TSI_INTERNAL_ERROR;

data/src/core/tsi/ssl_transport_security_utils.cc

@@ -109,9 +109,8 @@ tsi_result DoSslRead(SSL* ssl, unsigned char* unprotected_bytes,
         *unprotected_bytes_size = 0;
         return TSI_OK;
       case SSL_ERROR_WANT_WRITE:
-        gpr_log(
-            GPR_ERROR,
-            "Peer tried to renegotiate SSL connection. This is unsupported.");
+        LOG(ERROR)
+            << "Peer tried to renegotiate SSL connection. This is unsupported.";
         return TSI_UNIMPLEMENTED;
       case SSL_ERROR_SSL:
         LOG(ERROR) << "Corruption detected.";
@@ -266,7 +265,7 @@ bool VerifyCrlSignature(X509_CRL* crl, X509* issuer) {
   if (ikey == nullptr) {
     // Can't verify signature because we couldn't get the pubkey, fail the
     // check.
-    VLOG(2) << "Could not public key from certificate.";
+    VLOG(2) << "Could not get public key from certificate.";
     EVP_PKEY_free(ikey);
     return false;
   }

data/src/core/util/android/log.cc

@@ -30,18 +30,6 @@
 
 #include "src/core/lib/gprpp/crash.h"
 
-static android_LogPriority severity_to_log_priority(gpr_log_severity severity) {
-  switch (severity) {
-    case GPR_LOG_SEVERITY_DEBUG:
-      return ANDROID_LOG_DEBUG;
-    case GPR_LOG_SEVERITY_INFO:
-      return ANDROID_LOG_INFO;
-    case GPR_LOG_SEVERITY_ERROR:
-      return ANDROID_LOG_ERROR;
-  }
-  return ANDROID_LOG_DEFAULT;
-}
-
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
   // Avoid message construction if gpr_log_message won't log

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

@@ -35,6 +35,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.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"
@@ -192,9 +193,7 @@ HttpRequest::HttpRequest(
 HttpRequest::~HttpRequest() {
   grpc_channel_args_destroy(channel_args_);
   grpc_http_parser_destroy(&parser_);
-  if (own_endpoint_ && ep_ != nullptr) {
-    grpc_endpoint_destroy(ep_);
-  }
+  ep_.reset();
   CSliceUnref(request_text_);
   grpc_iomgr_unregister_object(&iomgr_obj_);
   grpc_slice_buffer_destroy(&incoming_);
@@ -231,10 +230,7 @@ void HttpRequest::Orphan() {
       handshake_mgr_->Shutdown(
           GRPC_ERROR_CREATE("HTTP request cancelled during handshake"));
     }
-    if (own_endpoint_ && ep_ != nullptr) {
-      grpc_endpoint_destroy(ep_);
-      ep_ = nullptr;
-    }
+    ep_.reset();
   }
   Unref();
 }
@@ -288,36 +284,30 @@ void HttpRequest::StartWrite() {
   CSliceRef(request_text_);
   grpc_slice_buffer_add(&outgoing_, request_text_);
   Ref().release();  // ref held by pending write
-  grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr,
+  grpc_endpoint_write(ep_.get(), &outgoing_, &done_write_, nullptr,
                       /*max_frame_size=*/INT_MAX);
 }
 
-void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
-  auto* args = static_cast<HandshakerArgs*>(arg);
-  RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(args->user_data));
+void HttpRequest::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
   if (g_test_only_on_handshake_done_intercept != nullptr) {
     // Run this testing intercept before the lock so that it has a chance to
     // do things like calling Orphan on the request
-    g_test_only_on_handshake_done_intercept(req.get());
+    g_test_only_on_handshake_done_intercept(this);
   }
-  MutexLock lock(&req->mu_);
-  req->own_endpoint_ = true;
-  if (!error.ok()) {
-    req->handshake_mgr_.reset();
-    req->NextAddress(error);
+  MutexLock lock(&mu_);
+  if (!result.ok()) {
+    handshake_mgr_.reset();
+    NextAddress(result.status());
     return;
   }
-  // Handshake completed, so we own fields in args
-  grpc_slice_buffer_destroy(args->read_buffer);
-  gpr_free(args->read_buffer);
-  req->ep_ = args->endpoint;
-  req->handshake_mgr_.reset();
-  if (req->cancelled_) {
-    req->NextAddress(
-        GRPC_ERROR_CREATE("HTTP request cancelled during handshake"));
+  // Handshake completed, so get the endpoint.
+  ep_ = std::move((*result)->endpoint);
+  handshake_mgr_.reset();
+  if (cancelled_) {
+    NextAddress(GRPC_ERROR_CREATE("HTTP request cancelled during handshake"));
     return;
   }
-  req->StartWrite();
+  StartWrite();
 }
 
 void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
@@ -343,13 +333,11 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
   handshake_mgr_ = MakeRefCounted<HandshakeManager>();
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
       HANDSHAKER_CLIENT, args, pollset_set_, handshake_mgr_.get());
-  Ref().release();  // ref held by pending handshake
-  grpc_endpoint* ep = ep_;
-  ep_ = nullptr;
-  own_endpoint_ = false;
-  handshake_mgr_->DoHandshake(ep, args, deadline_,
-                              /*acceptor=*/nullptr, OnHandshakeDone,
-                              /*user_data=*/this);
+  handshake_mgr_->DoHandshake(
+      nullptr, args, deadline_, /*acceptor=*/nullptr,
+      [self = Ref()](absl::StatusOr<HandshakerArgs*> result) {
+        self->OnHandshakeDone(std::move(result));
+      });
 }
 
 void HttpRequest::NextAddress(grpc_error_handle error) {

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

@@ -186,7 +186,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   void DoRead() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     Ref().release();  // ref held by pending read
-    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true,
+    grpc_endpoint_read(ep_.get(), &incoming_, &on_read_, /*urgent=*/true,
                        /*min_progress_size=*/1);
   }
 
@@ -221,7 +221,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   void StartWrite() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  static void OnHandshakeDone(void* arg, grpc_error_handle error);
+  void OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result);
 
   void DoHandshake(const grpc_resolved_address* addr)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -240,7 +240,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   grpc_closure continue_on_read_after_schedule_on_exec_ctx_;
   grpc_closure done_write_;
   grpc_closure continue_done_write_after_schedule_on_exec_ctx_;
-  grpc_endpoint* ep_ = nullptr;
+  OrphanablePtr<grpc_endpoint> ep_;
   grpc_closure* on_done_;
   ResourceQuotaRefPtr resource_quota_;
   grpc_polling_entity* pollent_;
@@ -248,7 +248,6 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   const absl::optional<std::function<void()>> test_only_generate_response_;
   Mutex mu_;
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
-  bool own_endpoint_ ABSL_GUARDED_BY(mu_) = true;
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
   grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
   std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);

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

@@ -25,10 +25,10 @@
 #include <algorithm>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 static char* buf2str(void* buffer, size_t length) {
   char* out = static_cast<char*>(gpr_malloc(length + 1));
@@ -377,8 +377,8 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
     case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
         if (GRPC_TRACE_FLAG_ENABLED(http1)) {
-          gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
-                  GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
+          LOG(ERROR) << "HTTP header max line length ("
+                     << GRPC_HTTP_PARSER_MAX_HEADER_LENGTH << ") exceeded";
         }
         return GRPC_ERROR_CREATE("HTTP header max line length exceeded");
       }

data/src/core/util/latent_see.cc

@@ -0,0 +1,113 @@
+// Copyright 2024 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.
+
+#include "src/core/util/latent_see.h"
+
+#ifdef GRPC_ENABLE_LATENT_SEE
+#include <chrono>
+#include <cstdint>
+
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+namespace latent_see {
+
+thread_local std::vector<Log::Event> Log::thread_events_;
+thread_local uint64_t Log::thread_id_ = Log::Get().next_thread_id_.fetch_add(1);
+std::atomic<uint64_t> Flow::next_flow_id_{1};
+
+std::string Log::GenerateJson() {
+  std::vector<RecordedEvent> events;
+  for (auto& fragment : fragments_) {
+    MutexLock lock(&fragment.mu);
+    events.insert(events.end(), fragment.events.begin(), fragment.events.end());
+  }
+  absl::optional<std::chrono::steady_clock::time_point> start_time;
+  for (auto& event : events) {
+    if (!start_time.has_value() || *start_time > event.event.timestamp) {
+      start_time = event.event.timestamp;
+    }
+  }
+  if (!start_time.has_value()) return "[]";
+  std::string json = "[\n";
+  bool first = true;
+  for (const auto& event : events) {
+    absl::string_view phase;
+    bool has_id;
+    switch (event.event.type) {
+      case EventType::kBegin:
+        phase = "B";
+        has_id = false;
+        break;
+      case EventType::kEnd:
+        phase = "E";
+        has_id = false;
+        break;
+      case EventType::kFlowStart:
+        phase = "s";
+        has_id = true;
+        break;
+      case EventType::kFlowEnd:
+        phase = "f";
+        has_id = true;
+        break;
+      case EventType::kMark:
+        phase = "i";
+        has_id = false;
+        break;
+    }
+    if (!first) absl::StrAppend(&json, ",\n");
+    first = false;
+    absl::StrAppend(&json, "{\"name\": ", event.event.metadata->name,
+                    ", \"ph\": \"", phase, "\", \"ts\": ",
+                    std::chrono::duration<double, std::micro>(
+                        event.event.timestamp - *start_time)
+                        .count(),
+                    ", \"pid\": 0, \"tid\": ", event.thread_id);
+    if (has_id) {
+      absl::StrAppend(&json, ", \"id\": ", event.event.id);
+    }
+    if (event.event.type == EventType::kFlowEnd) {
+      absl::StrAppend(&json, ", \"bp\": \"e\"");
+    }
+    absl::StrAppend(&json, ", \"args\": {\"file\": \"",
+                    event.event.metadata->file,
+                    "\", \"line\": ", event.event.metadata->line,
+                    ", \"batch\": ", event.batch_id, "}}");
+  }
+  absl::StrAppend(&json, "\n]");
+  return json;
+}
+
+void Log::FlushThreadLog() {
+  auto& thread_events = thread_events_;
+  if (thread_events.empty()) return;
+  auto& log = Get();
+  const auto batch_id =
+      log.next_batch_id_.fetch_add(1, std::memory_order_relaxed);
+  auto& fragment = log.fragments_.this_cpu();
+  const auto thread_id = thread_id_;
+  {
+    MutexLock lock(&fragment.mu);
+    for (auto event : thread_events) {
+      fragment.events.push_back(RecordedEvent{thread_id, batch_id, event});
+    }
+  }
+  thread_events.clear();
+}
+
+}  // namespace latent_see
+}  // namespace grpc_core
+#endif