grpc 1.63.0 → 1.66.0

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/oauth2/oauth2_credentials.h"
 
 #include <stdlib.h>
@@ -29,18 +27,21 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
@@ -49,19 +50,18 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/http/httpcli_ssl_credentials.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_reader.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/util/json_util.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/http_client/httpcli_ssl_credentials.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_reader.h"
 
 using grpc_core::Json;
 
@@ -85,7 +85,7 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_json(
   memset(&result, 0, sizeof(grpc_auth_refresh_token));
   result.type = GRPC_AUTH_JSON_TYPE_INVALID;
   if (json.type() != Json::Type::kObject) {
-    gpr_log(GPR_ERROR, "Invalid json.");
+    LOG(ERROR) << "Invalid json.";
     goto end;
   }
 
@@ -116,8 +116,7 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
   Json json;
   auto json_or = grpc_core::JsonParse(json_string);
   if (!json_or.ok()) {
-    gpr_log(GPR_ERROR, "JSON parsing failed: %s",
-            json_or.status().ToString().c_str());
+    LOG(ERROR) << "JSON parsing failed: " << json_or.status();
   } else {
     json = std::move(*json_or);
   }
@@ -160,7 +159,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
   grpc_credentials_status status = GRPC_CREDENTIALS_OK;
 
   if (response == nullptr) {
-    gpr_log(GPR_ERROR, "Received NULL response.");
+    LOG(ERROR) << "Received NULL response.";
     status = GRPC_CREDENTIALS_ERROR;
     goto end;
   }
@@ -173,9 +172,10 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
   }
 
   if (response->status != 200) {
-    gpr_log(GPR_ERROR, "Call to http server ended with error %d [%s].",
-            response->status,
-            null_terminated_body != nullptr ? null_terminated_body : "");
+    LOG(ERROR) << "Call to http server ended with error " << response->status
+               << " ["
+               << (null_terminated_body != nullptr ? null_terminated_body : "")
+               << "]";
     status = GRPC_CREDENTIALS_ERROR;
     goto end;
   } else {
@@ -186,20 +186,20 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     auto json = grpc_core::JsonParse(
         null_terminated_body != nullptr ? null_terminated_body : "");
     if (!json.ok()) {
-      gpr_log(GPR_ERROR, "Could not parse JSON from %s: %s",
-              null_terminated_body, json.status().ToString().c_str());
+      LOG(ERROR) << "Could not parse JSON from " << null_terminated_body << ": "
+                 << json.status();
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
     if (json->type() != Json::Type::kObject) {
-      gpr_log(GPR_ERROR, "Response should be a JSON object");
+      LOG(ERROR) << "Response should be a JSON object";
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
     it = json->object().find("access_token");
     if (it == json->object().end() ||
         it->second.type() != Json::Type::kString) {
-      gpr_log(GPR_ERROR, "Missing or invalid access_token in JSON.");
+      LOG(ERROR) << "Missing or invalid access_token in JSON.";
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
@@ -207,7 +207,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     it = json->object().find("token_type");
     if (it == json->object().end() ||
         it->second.type() != Json::Type::kString) {
-      gpr_log(GPR_ERROR, "Missing or invalid token_type in JSON.");
+      LOG(ERROR) << "Missing or invalid token_type in JSON.";
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
@@ -215,7 +215,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     it = json->object().find("expires_in");
     if (it == json->object().end() ||
         it->second.type() != Json::Type::kNumber) {
-      gpr_log(GPR_ERROR, "Missing or invalid expires_in in JSON.");
+      LOG(ERROR) << "Missing or invalid expires_in in JSON.";
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
@@ -395,7 +395,7 @@ class grpc_compute_engine_token_fetcher_credentials
     auto uri = grpc_core::URI::Create("http", GRPC_COMPUTE_ENGINE_METADATA_HOST,
                                       GRPC_COMPUTE_ENGINE_METADATA_TOKEN_PATH,
                                       {} /* query params */, "" /* fragment */);
-    GPR_ASSERT(uri.ok());  // params are hardcoded
+    CHECK(uri.ok());  // params are hardcoded
     http_request_ = grpc_core::HttpRequest::Get(
         std::move(*uri), nullptr /* channel args */, pollent, &request,
         deadline,
@@ -422,9 +422,9 @@ class grpc_compute_engine_token_fetcher_credentials
 
 grpc_call_credentials* grpc_google_compute_engine_credentials_create(
     void* reserved) {
-  GRPC_API_TRACE("grpc_compute_engine_credentials_create(reserved=%p)", 1,
-                 (reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_compute_engine_credentials_create(reserved=" << reserved << ")";
+  CHECK_EQ(reserved, nullptr);
   return grpc_core::MakeRefCounted<
              grpc_compute_engine_token_fetcher_credentials>()
       .release();
@@ -461,7 +461,7 @@ void grpc_google_refresh_token_credentials::fetch_oauth2(
   auto uri = grpc_core::URI::Create("https", GRPC_GOOGLE_OAUTH2_SERVICE_HOST,
                                     GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH,
                                     {} /* query params */, "" /* fragment */);
-  GPR_ASSERT(uri.ok());  // params are hardcoded
+  CHECK(uri.ok());  // params are hardcoded
   http_request_ = grpc_core::HttpRequest::Post(
       std::move(*uri), nullptr /* channel args */, pollent, &request, deadline,
       GRPC_CLOSURE_INIT(&http_post_cb_closure_, response_cb, metadata_req,
@@ -478,7 +478,7 @@ grpc_core::RefCountedPtr<grpc_call_credentials>
 grpc_refresh_token_credentials_create_from_auth_refresh_token(
     grpc_auth_refresh_token refresh_token) {
   if (!grpc_auth_refresh_token_is_valid(&refresh_token)) {
-    gpr_log(GPR_ERROR, "Invalid input for refresh token credentials creation");
+    LOG(ERROR) << "Invalid input for refresh token credentials creation";
     return nullptr;
   }
   return grpc_core::MakeRefCounted<grpc_google_refresh_token_credentials>(
@@ -511,13 +511,12 @@ grpc_call_credentials* grpc_google_refresh_token_credentials_create(
     const char* json_refresh_token, void* reserved) {
   grpc_auth_refresh_token token =
       grpc_auth_refresh_token_create_from_string(json_refresh_token);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace)) {
-    gpr_log(GPR_INFO,
-            "grpc_refresh_token_credentials_create(json_refresh_token=%s, "
-            "reserved=%p)",
-            create_loggable_refresh_token(&token).c_str(), reserved);
+  if (GRPC_TRACE_FLAG_ENABLED(api)) {
+    LOG(INFO) << "grpc_refresh_token_credentials_create(json_refresh_token="
+              << create_loggable_refresh_token(&token)
+              << ", reserved=" << reserved << ")";
   }
-  GPR_ASSERT(reserved == nullptr);
+  CHECK_EQ(reserved, nullptr);
   return grpc_refresh_token_credentials_create_from_auth_refresh_token(token)
       .release();
 }
@@ -539,8 +538,8 @@ void MaybeAddToBody(const char* field_name, const char* field,
 grpc_error_handle LoadTokenFile(const char* path, grpc_slice* token) {
   auto slice = LoadFile(path, /*add_null_terminator=*/true);
   if (!slice.ok()) return slice.status();
-  if (slice->length() == 0) {
-    gpr_log(GPR_ERROR, "Token file %s is empty", path);
+  if (slice->empty()) {
+    LOG(ERROR) << "Token file " << path << " is empty";
     return GRPC_ERROR_CREATE("Token file is empty.");
   }
   *token = slice->TakeCSlice();
@@ -700,12 +699,12 @@ absl::StatusOr<URI> ValidateStsCredentialsOptions(
 
 grpc_call_credentials* grpc_sts_credentials_create(
     const grpc_sts_credentials_options* options, void* reserved) {
-  GPR_ASSERT(reserved == nullptr);
+  CHECK_EQ(reserved, nullptr);
   absl::StatusOr<grpc_core::URI> sts_url =
       grpc_core::ValidateStsCredentialsOptions(options);
   if (!sts_url.ok()) {
-    gpr_log(GPR_ERROR, "STS Credentials creation failed. Error: %s.",
-            sts_url.status().ToString().c_str());
+    LOG(ERROR) << "STS Credentials creation failed. Error: "
+               << sts_url.status();
     return nullptr;
   }
   return grpc_core::MakeRefCounted<grpc_core::StsTokenFetcherCredentials>(
@@ -743,11 +742,10 @@ std::string grpc_access_token_credentials::debug_string() {
 
 grpc_call_credentials* grpc_access_token_credentials_create(
     const char* access_token, void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_access_token_credentials_create(access_token=<redacted>, "
-      "reserved=%p)",
-      1, (reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO) << "grpc_access_token_credentials_create(access_"
+                               "token=<redacted>, reserved="
+                            << reserved << ")";
+  CHECK_EQ(reserved, nullptr);
   return grpc_core::MakeRefCounted<grpc_access_token_credentials>(access_token)
       .release();
 }

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.h

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_OAUTH2_OAUTH2_CREDENTIALS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_OAUTH2_OAUTH2_CREDENTIALS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <string>
 #include <utility>
@@ -28,28 +26,30 @@
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
-#include "src/core/lib/http/httpcli.h"
-#include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/http_client/httpcli.h"
+#include "src/core/util/http_client/parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/useful.h"
 
 // Constants.
 #define GRPC_STS_POST_MINIMAL_BODY_FORMAT_STRING                               \

data/src/core/lib/security/credentials/plugin/plugin_credentials.cc

@@ -16,31 +16,28 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/plugin/plugin_credentials.h"
 
 #include <atomic>
 #include <memory>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
-grpc_core::TraceFlag grpc_plugin_credentials_trace(false, "plugin_credentials");
-
 grpc_plugin_credentials::~grpc_plugin_credentials() {
   if (plugin_.state != nullptr && plugin_.destroy != nullptr) {
     plugin_.destroy(plugin_.state);
@@ -83,7 +80,7 @@ grpc_plugin_credentials::PendingRequest::ProcessPluginResult(
                  !GRPC_LOG_IF_ERROR(
                      "validate_metadata_from_plugin",
                      grpc_validate_header_nonbin_value_is_legal(md[i].value))) {
-        gpr_log(GPR_ERROR, "Plugin added invalid metadata value.");
+        LOG(ERROR) << "Plugin added invalid metadata value.";
         seen_illegal_header = true;
         break;
       }
@@ -124,11 +121,9 @@ void grpc_plugin_credentials::PendingRequest::RequestMetadataReady(
                               GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP);
   grpc_core::RefCountedPtr<grpc_plugin_credentials::PendingRequest> r(
       static_cast<grpc_plugin_credentials::PendingRequest*>(request));
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_plugin_credentials_trace)) {
-    gpr_log(GPR_INFO,
-            "plugin_credentials[%p]: request %p: plugin returned "
-            "asynchronously",
-            r->creds(), r.get());
+  if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
+    LOG(INFO) << "plugin_credentials[" << r->creds() << "]: request " << r.get()
+              << ": plugin returned asynchronously";
   }
   for (size_t i = 0; i < num_md; ++i) {
     grpc_metadata p;
@@ -155,9 +150,9 @@ grpc_plugin_credentials::GetRequestMetadata(
       RefAsSubclass<grpc_plugin_credentials>(), std::move(initial_metadata),
       args);
   // Invoke the plugin.  The callback holds a ref to us.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_plugin_credentials_trace)) {
-    gpr_log(GPR_INFO, "plugin_credentials[%p]: request %p: invoking plugin",
-            this, request.get());
+  if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
+    LOG(INFO) << "plugin_credentials[" << this << "]: request " << request.get()
+              << ": invoking plugin";
   }
   grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX];
   size_t num_creds_md = 0;
@@ -173,20 +168,16 @@ grpc_plugin_credentials::GetRequestMetadata(
                             child_request.get(), creds_md, &num_creds_md,
                             &status, &error_details)) {
     child_request.release();
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_plugin_credentials_trace)) {
-      gpr_log(GPR_INFO,
-              "plugin_credentials[%p]: request %p: plugin will return "
-              "asynchronously",
-              this, request.get());
+    if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
+      LOG(INFO) << "plugin_credentials[" << this << "]: request "
+                << request.get() << ": plugin will return asynchronously";
     }
     return [request] { return request->PollAsyncResult(); };
   }
   // Synchronous return.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_plugin_credentials_trace)) {
-    gpr_log(GPR_INFO,
-            "plugin_credentials[%p]: request %p: plugin returned "
-            "synchronously",
-            this, request.get());
+  if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
+    LOG(INFO) << "plugin_credentials[" << this << "]: request " << request.get()
+              << ": plugin returned synchronously";
   }
   auto result = request->ProcessPluginResult(creds_md, num_creds_md, status,
                                              error_details);
@@ -208,8 +199,9 @@ grpc_plugin_credentials::grpc_plugin_credentials(
 grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
     grpc_metadata_credentials_plugin plugin,
     grpc_security_level min_security_level, void* reserved) {
-  GRPC_API_TRACE("grpc_metadata_credentials_create_from_plugin(reserved=%p)", 1,
-                 (reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_metadata_credentials_create_from_plugin(reserved=" << reserved
+      << ")";
+  CHECK_EQ(reserved, nullptr);
   return new grpc_plugin_credentials(plugin, min_security_level);
 }

data/src/core/lib/security/credentials/plugin/plugin_credentials.h

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_PLUGIN_PLUGIN_CREDENTIALS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_PLUGIN_PLUGIN_CREDENTIALS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <atomic>
@@ -30,13 +28,14 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/status/statusor.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/grpc_security_constants.h>
 #include <grpc/status.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
@@ -47,8 +46,7 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/transport.h"
-
-extern grpc_core::TraceFlag grpc_plugin_credentials_trace;
+#include "src/core/util/useful.h"
 
 // This type is forward declared as a C struct and we cannot define it as a
 // class. Otherwise, compiler will complain about type mismatch due to

data/src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/ssl/ssl_credentials.h"
 
 #include <string.h>
@@ -25,17 +23,18 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
 #include "src/core/tsi/ssl_transport_security.h"
 #include "src/core/tsi/transport_security_interface.h"
@@ -54,7 +53,7 @@ grpc_ssl_credentials::grpc_ssl_credentials(
     const char* pem_root_certs =
         grpc_core::DefaultSslRootStore::GetPemRootCerts();
     if (pem_root_certs == nullptr) {
-      gpr_log(GPR_ERROR, "Could not get default pem root certs.");
+      LOG(ERROR) << "Could not get default pem root certs.";
     } else {
       char* default_roots = gpr_strdup(pem_root_certs);
       config_.pem_root_certs = default_roots;
@@ -85,9 +84,8 @@ grpc_ssl_credentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
     const char* target, grpc_core::ChannelArgs* args) {
   if (config_.pem_root_certs == nullptr) {
-    gpr_log(GPR_ERROR,
-            "No root certs in config. Client-side security connector must have "
-            "root certs.");
+    LOG(ERROR) << "No root certs in config. Client-side security connector "
+                  "must have root certs.";
     return nullptr;
   }
   absl::optional<std::string> overridden_target_name =
@@ -111,9 +109,7 @@ grpc_ssl_credentials::create_security_connector(
         &config_, config_.pem_root_certs, root_store_, session_cache,
         &factory_with_cache);
     if (status != GRPC_SECURITY_OK) {
-      gpr_log(GPR_ERROR,
-              "InitializeClientHandshakerFactory returned bad "
-              "status.");
+      LOG(ERROR) << "InitializeClientHandshakerFactory returned bad status.";
       return nullptr;
     }
     security_connector = grpc_ssl_channel_security_connector_create(
@@ -150,8 +146,8 @@ void grpc_ssl_credentials::build_config(
     const grpc_ssl_verify_peer_options* verify_options) {
   config_.pem_root_certs = gpr_strdup(pem_root_certs);
   if (pem_key_cert_pair != nullptr) {
-    GPR_ASSERT(pem_key_cert_pair->private_key != nullptr);
-    GPR_ASSERT(pem_key_cert_pair->cert_chain != nullptr);
+    CHECK_NE(pem_key_cert_pair->private_key, nullptr);
+    CHECK_NE(pem_key_cert_pair->cert_chain, nullptr);
     config_.pem_key_cert_pair = static_cast<tsi_ssl_pem_key_cert_pair*>(
         gpr_zalloc(sizeof(tsi_ssl_pem_key_cert_pair)));
     config_.pem_key_cert_pair->cert_chain =
@@ -196,9 +192,8 @@ grpc_security_status grpc_ssl_credentials::InitializeClientHandshakerFactory(
                            config->pem_key_cert_pair->cert_chain != nullptr;
   tsi_ssl_client_handshaker_options options;
   if (pem_root_certs == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Handshaker factory creation failed. pem_root_certs cannot be nullptr");
+    LOG(ERROR) << "Handshaker factory creation failed. pem_root_certs cannot "
+                  "be nullptr";
     return GRPC_SECURITY_ERROR;
   }
   options.pem_root_certs = pem_root_certs;
@@ -217,8 +212,8 @@ grpc_security_status grpc_ssl_credentials::InitializeClientHandshakerFactory(
                                                             handshaker_factory);
   gpr_free(options.alpn_protocols);
   if (result != TSI_OK) {
-    gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
-            tsi_result_to_string(result));
+    LOG(ERROR) << "Handshaker factory creation failed with "
+               << tsi_result_to_string(result);
     return GRPC_SECURITY_ERROR;
   }
   return GRPC_SECURITY_OK;
@@ -229,13 +224,12 @@ grpc_security_status grpc_ssl_credentials::InitializeClientHandshakerFactory(
 grpc_channel_credentials* grpc_ssl_credentials_create(
     const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
     const verify_peer_options* verify_options, void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_ssl_credentials_create(pem_root_certs=%s, "
-      "pem_key_cert_pair=%p, "
-      "verify_options=%p, "
-      "reserved=%p)",
-      4, (pem_root_certs, pem_key_cert_pair, verify_options, reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_ssl_credentials_create(pem_root_certs=" << pem_root_certs
+      << ", pem_key_cert_pair=" << pem_key_cert_pair
+      << ", verify_options=" << verify_options << ", reserved=" << reserved
+      << ")";
+  CHECK_EQ(reserved, nullptr);
 
   return new grpc_ssl_credentials(
       pem_root_certs, pem_key_cert_pair,
@@ -245,13 +239,12 @@ grpc_channel_credentials* grpc_ssl_credentials_create(
 grpc_channel_credentials* grpc_ssl_credentials_create_ex(
     const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
     const grpc_ssl_verify_peer_options* verify_options, void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_ssl_credentials_create(pem_root_certs=%s, "
-      "pem_key_cert_pair=%p, "
-      "verify_options=%p, "
-      "reserved=%p)",
-      4, (pem_root_certs, pem_key_cert_pair, verify_options, reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_ssl_credentials_create(pem_root_certs=" << pem_root_certs
+      << ", pem_key_cert_pair=" << pem_key_cert_pair
+      << ", verify_options=" << verify_options << ", reserved=" << reserved
+      << ")";
+  CHECK_EQ(reserved, nullptr);
 
   return new grpc_ssl_credentials(pem_root_certs, pem_key_cert_pair,
                                   verify_options);
@@ -301,13 +294,13 @@ tsi_ssl_pem_key_cert_pair* grpc_convert_grpc_to_tsi_cert_pairs(
     size_t num_key_cert_pairs) {
   tsi_ssl_pem_key_cert_pair* tsi_pairs = nullptr;
   if (num_key_cert_pairs > 0) {
-    GPR_ASSERT(pem_key_cert_pairs != nullptr);
+    CHECK_NE(pem_key_cert_pairs, nullptr);
     tsi_pairs = static_cast<tsi_ssl_pem_key_cert_pair*>(
         gpr_zalloc(num_key_cert_pairs * sizeof(tsi_ssl_pem_key_cert_pair)));
   }
   for (size_t i = 0; i < num_key_cert_pairs; i++) {
-    GPR_ASSERT(pem_key_cert_pairs[i].private_key != nullptr);
-    GPR_ASSERT(pem_key_cert_pairs[i].cert_chain != nullptr);
+    CHECK_NE(pem_key_cert_pairs[i].private_key, nullptr);
+    CHECK_NE(pem_key_cert_pairs[i].cert_chain, nullptr);
     tsi_pairs[i].cert_chain = gpr_strdup(pem_key_cert_pairs[i].cert_chain);
     tsi_pairs[i].private_key = gpr_strdup(pem_key_cert_pairs[i].private_key);
   }
@@ -344,14 +337,14 @@ grpc_ssl_server_certificate_config* grpc_ssl_server_certificate_config_create(
           gpr_zalloc(sizeof(grpc_ssl_server_certificate_config)));
   config->pem_root_certs = gpr_strdup(pem_root_certs);
   if (num_key_cert_pairs > 0) {
-    GPR_ASSERT(pem_key_cert_pairs != nullptr);
+    CHECK_NE(pem_key_cert_pairs, nullptr);
     config->pem_key_cert_pairs = static_cast<grpc_ssl_pem_key_cert_pair*>(
         gpr_zalloc(num_key_cert_pairs * sizeof(grpc_ssl_pem_key_cert_pair)));
   }
   config->num_key_cert_pairs = num_key_cert_pairs;
   for (size_t i = 0; i < num_key_cert_pairs; i++) {
-    GPR_ASSERT(pem_key_cert_pairs[i].private_key != nullptr);
-    GPR_ASSERT(pem_key_cert_pairs[i].cert_chain != nullptr);
+    CHECK_NE(pem_key_cert_pairs[i].private_key, nullptr);
+    CHECK_NE(pem_key_cert_pairs[i].cert_chain, nullptr);
     config->pem_key_cert_pairs[i].cert_chain =
         gpr_strdup(pem_key_cert_pairs[i].cert_chain);
     config->pem_key_cert_pairs[i].private_key =
@@ -378,7 +371,7 @@ grpc_ssl_server_credentials_create_options_using_config(
     grpc_ssl_server_certificate_config* config) {
   grpc_ssl_server_credentials_options* options = nullptr;
   if (config == nullptr) {
-    gpr_log(GPR_ERROR, "Certificate config must not be NULL.");
+    LOG(ERROR) << "Certificate config must not be NULL.";
     goto done;
   }
   options = static_cast<grpc_ssl_server_credentials_options*>(
@@ -394,7 +387,7 @@ grpc_ssl_server_credentials_create_options_using_config_fetcher(
     grpc_ssl_client_certificate_request_type client_certificate_request,
     grpc_ssl_server_certificate_config_callback cb, void* user_data) {
   if (cb == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid certificate config callback parameter.");
+    LOG(ERROR) << "Invalid certificate config callback parameter.";
     return nullptr;
   }
 
@@ -429,14 +422,13 @@ grpc_server_credentials* grpc_ssl_server_credentials_create_ex(
     size_t num_key_cert_pairs,
     grpc_ssl_client_certificate_request_type client_certificate_request,
     void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_ssl_server_credentials_create_ex("
-      "pem_root_certs=%s, pem_key_cert_pairs=%p, num_key_cert_pairs=%lu, "
-      "client_certificate_request=%d, reserved=%p)",
-      5,
-      (pem_root_certs, pem_key_cert_pairs, (unsigned long)num_key_cert_pairs,
-       client_certificate_request, reserved));
-  GPR_ASSERT(reserved == nullptr);
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_ssl_server_credentials_create_ex(pem_root_certs="
+      << pem_root_certs << ", pem_key_cert_pairs=" << pem_key_cert_pairs
+      << ", num_key_cert_pairs=" << (unsigned long)num_key_cert_pairs
+      << ", client_certificate_request=" << client_certificate_request
+      << ", reserved=" << reserved << ")";
+  CHECK_EQ(reserved, nullptr);
 
   grpc_ssl_server_certificate_config* cert_config =
       grpc_ssl_server_certificate_config_create(
@@ -453,20 +445,18 @@ grpc_server_credentials* grpc_ssl_server_credentials_create_with_options(
   grpc_server_credentials* retval = nullptr;
 
   if (options == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid options trying to create SSL server credentials.");
+    LOG(ERROR) << "Invalid options trying to create SSL server credentials.";
     goto done;
   }
 
   if (options->certificate_config == nullptr &&
       options->certificate_config_fetcher == nullptr) {
-    gpr_log(GPR_ERROR,
-            "SSL server credentials options must specify either "
-            "certificate config or fetcher.");
+    LOG(ERROR) << "SSL server credentials options must specify either "
+                  "certificate config or fetcher.";
     goto done;
   } else if (options->certificate_config_fetcher != nullptr &&
              options->certificate_config_fetcher->cb == nullptr) {
-    gpr_log(GPR_ERROR, "Certificate config fetcher callback must not be NULL.");
+    LOG(ERROR) << "Certificate config fetcher callback must not be NULL.";
     goto done;
   }