grpc 1.64.3 → 1.65.0

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

@@ -24,11 +24,11 @@
 #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>
 
@@ -54,7 +54,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 +85,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 +110,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(
@@ -196,9 +193,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 +213,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;
@@ -378,7 +374,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 +390,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;
   }
 
@@ -453,20 +449,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;
   }
 

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

@@ -30,13 +30,13 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/security/security_connector/ssl/ssl_security_connector.h"
 #include "src/core/tsi/ssl_transport_security.h"
+#include "src/core/util/useful.h"
 
 class grpc_ssl_credentials : public grpc_channel_credentials {
  public:

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -24,11 +24,11 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 
 #include <grpc/credentials.h>
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
@@ -123,9 +123,9 @@ FileWatcherCertificateProvider::FileWatcherCertificateProvider(
       refresh_interval_sec_(refresh_interval_sec),
       distributor_(MakeRefCounted<grpc_tls_certificate_distributor>()) {
   if (refresh_interval_sec_ < kMinimumFileWatcherRefreshIntervalSeconds) {
-    gpr_log(GPR_INFO,
-            "FileWatcherCertificateProvider refresh_interval_sec_ set to value "
-            "less than minimum. Overriding configured value to minimum.");
+    LOG(INFO) << "FileWatcherCertificateProvider refresh_interval_sec_ set to "
+                 "value less than minimum. Overriding configured value to "
+                 "minimum.";
     refresh_interval_sec_ = kMinimumFileWatcherRefreshIntervalSeconds;
   }
   // Private key and identity cert files must be both set or both unset.
@@ -284,9 +284,8 @@ FileWatcherCertificateProvider::ReadRootCertificatesFromFile(
   auto root_slice =
       LoadFile(root_cert_full_path, /*add_null_terminator=*/false);
   if (!root_slice.ok()) {
-    gpr_log(GPR_ERROR, "Reading file %s failed: %s",
-            root_cert_full_path.c_str(),
-            root_slice.status().ToString().c_str());
+    LOG(ERROR) << "Reading file " << root_cert_full_path
+               << " failed: " << root_slice.status();
     return absl::nullopt;
   }
   return std::string(root_slice->as_string_view());
@@ -316,34 +315,29 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     time_t identity_key_ts_before =
         GetModificationTime(private_key_path.c_str());
     if (identity_key_ts_before == 0) {
-      gpr_log(
-          GPR_ERROR,
-          "Failed to get the file's modification time of %s. Start retrying...",
-          private_key_path.c_str());
+      LOG(ERROR) << "Failed to get the file's modification time of "
+                 << private_key_path << ". Start retrying...";
       continue;
     }
     time_t identity_cert_ts_before =
         GetModificationTime(identity_certificate_path.c_str());
     if (identity_cert_ts_before == 0) {
-      gpr_log(
-          GPR_ERROR,
-          "Failed to get the file's modification time of %s. Start retrying...",
-          identity_certificate_path.c_str());
+      LOG(ERROR) << "Failed to get the file's modification time of "
+                 << identity_certificate_path << ". Start retrying...";
       continue;
     }
     // Read the identity files.
     auto key_slice = LoadFile(private_key_path, /*add_null_terminator=*/false);
     if (!key_slice.ok()) {
-      gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
-              private_key_path.c_str(), key_slice.status().ToString().c_str());
+      LOG(ERROR) << "Reading file " << private_key_path
+                 << " failed: " << key_slice.status() << ". Start retrying...";
       continue;
     }
     auto cert_slice =
         LoadFile(identity_certificate_path, /*add_null_terminator=*/false);
     if (!cert_slice.ok()) {
-      gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
-              identity_certificate_path.c_str(),
-              cert_slice.status().ToString().c_str());
+      LOG(ERROR) << "Reading file " << identity_certificate_path
+                 << " failed: " << cert_slice.status() << ". Start retrying...";
       continue;
     }
     std::string private_key(key_slice->as_string_view());
@@ -354,25 +348,22 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     time_t identity_key_ts_after =
         GetModificationTime(private_key_path.c_str());
     if (identity_key_ts_before != identity_key_ts_after) {
-      gpr_log(GPR_ERROR,
-              "Last modified time before and after reading %s is not the same. "
-              "Start retrying...",
-              private_key_path.c_str());
+      LOG(ERROR) << "Last modified time before and after reading "
+                 << private_key_path << " is not the same. Start retrying...";
       continue;
     }
     time_t identity_cert_ts_after =
         GetModificationTime(identity_certificate_path.c_str());
     if (identity_cert_ts_before != identity_cert_ts_after) {
-      gpr_log(GPR_ERROR,
-              "Last modified time before and after reading %s is not the same. "
-              "Start retrying...",
-              identity_certificate_path.c_str());
+      LOG(ERROR) << "Last modified time before and after reading "
+                 << identity_certificate_path
+                 << " is not the same. Start retrying...";
       continue;
     }
     return identity_pairs;
   }
-  gpr_log(GPR_ERROR,
-          "All retry attempts failed. Will try again after the next interval.");
+  LOG(ERROR) << "All retry attempts failed. Will try again after the next "
+                "interval.";
   return absl::nullopt;
 }
 

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h

@@ -33,7 +33,6 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.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/sync.h"
@@ -41,6 +40,7 @@
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
+#include "src/core/util/useful.h"
 
 // Interface for a grpc_tls_certificate_provider that handles the process to
 // fetch credentials and validation contexts. Implementations are free to rely

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h

@@ -30,10 +30,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/util/useful.h"
 
 // An abstraction of the verifier that all verifier subclasses should extend.
 struct grpc_tls_certificate_verifier

data/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc

@@ -21,9 +21,9 @@
 #include <memory>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/grpc_crl_provider.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -128,10 +128,10 @@ void grpc_tls_credentials_options_set_tls_session_key_log_file_path(
   // Tls session key logging is assumed to be enabled if the specified log
   // file is non-empty.
   if (path != nullptr) {
-    gpr_log(GPR_INFO,
-            "Enabling TLS session key logging with keys stored at: %s", path);
+    LOG(INFO) << "Enabling TLS session key logging with keys stored at: "
+              << path;
   } else {
-    gpr_log(GPR_INFO, "Disabling TLS session key logging");
+    LOG(INFO) << "Disabling TLS session key logging";
   }
   options->set_tls_session_key_log_file_path(path != nullptr ? path : "");
 }

data/src/core/lib/security/credentials/tls/grpc_tls_crl_provider.cc

@@ -35,14 +35,13 @@
 #include <openssl/x509.h>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/types/span.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/directory_reader.h"
 #include "src/core/lib/gprpp/load_file.h"
@@ -130,9 +129,8 @@ absl::StatusOr<std::shared_ptr<CrlProvider>> CreateStaticCrlProvider(
     }
     bool inserted = crl_map.emplace((*crl)->Issuer(), std::move(*crl)).second;
     if (!inserted) {
-      gpr_log(GPR_ERROR,
-              "StaticCrlProvider received multiple CRLs with the same issuer. "
-              "The first one in the span will be used.");
+      LOG(ERROR) << "StaticCrlProvider received multiple CRLs with the same "
+                    "issuer. The first one in the span will be used.";
     }
   }
   StaticCrlProvider provider = StaticCrlProvider(std::move(crl_map));

data/src/core/lib/security/credentials/tls/tls_credentials.cc

@@ -22,49 +22,48 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security_constants.h>
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 #include "src/core/lib/security/security_connector/tls/tls_security_connector.h"
 #include "src/core/tsi/ssl/session_cache/ssl_session_cache.h"
+#include "src/core/util/useful.h"
 
 namespace {
 
 bool CredentialOptionSanityCheck(grpc_tls_credentials_options* options,
                                  bool is_client) {
   if (options == nullptr) {
-    gpr_log(GPR_ERROR, "TLS credentials options is nullptr.");
+    LOG(ERROR) << "TLS credentials options is nullptr.";
     return false;
   }
   // In this case, there will be non-retriable handshake errors.
   if (options->min_tls_version() > options->max_tls_version()) {
-    gpr_log(GPR_ERROR, "TLS min version must not be higher than max version.");
+    LOG(ERROR) << "TLS min version must not be higher than max version.";
     grpc_tls_credentials_options_destroy(options);
     return false;
   }
   if (options->max_tls_version() > grpc_tls_version::TLS1_3) {
-    gpr_log(GPR_ERROR, "TLS max version must not be higher than v1.3.");
+    LOG(ERROR) << "TLS max version must not be higher than v1.3.";
     grpc_tls_credentials_options_destroy(options);
     return false;
   }
   if (options->min_tls_version() < grpc_tls_version::TLS1_2) {
-    gpr_log(GPR_ERROR, "TLS min version must not be lower than v1.2.");
+    LOG(ERROR) << "TLS min version must not be lower than v1.2.";
     grpc_tls_credentials_options_destroy(options);
     return false;
   }
   if (!options->crl_directory().empty() && options->crl_provider() != nullptr) {
-    gpr_log(GPR_ERROR,
-            "Setting crl_directory and crl_provider not supported. Using the "
-            "crl_provider.");
+    LOG(ERROR) << "Setting crl_directory and crl_provider not supported. Using "
+                  "the crl_provider.";
     // TODO(gtcooke94) - Maybe return false here. Right now object lifetime of
     // this options struct is leaky if false is returned and represents a more
     // complex fix to handle in another PR.
@@ -73,21 +72,20 @@ bool CredentialOptionSanityCheck(grpc_tls_credentials_options* options,
   // indicate callers are doing something wrong with the API.
   if (is_client && options->cert_request_type() !=
                        GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE) {
-    gpr_log(GPR_ERROR,
-            "Client's credentials options should not set cert_request_type.");
+    LOG(ERROR)
+        << "Client's credentials options should not set cert_request_type.";
   }
   if (!is_client && !options->verify_server_cert()) {
-    gpr_log(GPR_ERROR,
-            "Server's credentials options should not set verify_server_cert.");
+    LOG(ERROR)
+        << "Server's credentials options should not set verify_server_cert.";
   }
   // In the following conditions, there could be severe security issues.
   if (is_client && options->certificate_verifier() == nullptr) {
     // If no verifier is specified on the client side, use the hostname verifier
     // as default. Users who want to bypass all the verifier check should
     // implement an external verifier instead.
-    gpr_log(GPR_INFO,
-            "No verifier specified on the client side. Using default hostname "
-            "verifier");
+    LOG(INFO) << "No verifier specified on the client side. Using default "
+                 "hostname verifier";
     options->set_certificate_verifier(
         grpc_core::MakeRefCounted<grpc_core::HostNameCertificateVerifier>());
   }

data/src/core/lib/security/credentials/tls/tls_utils.cc

@@ -22,11 +22,11 @@
 
 #include <algorithm>
 
+#include "absl/log/log.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {
@@ -99,11 +99,11 @@ absl::string_view GetAuthPropertyValue(grpc_auth_context* context,
       grpc_auth_context_find_properties_by_name(context, property_name);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
   if (prop == nullptr) {
-    gpr_log(GPR_DEBUG, "No value found for %s property.", property_name);
+    VLOG(2) << "No value found for " << property_name << " property.";
     return "";
   }
   if (grpc_auth_property_iterator_next(&it) != nullptr) {
-    gpr_log(GPR_DEBUG, "Multiple values found for %s property.", property_name);
+    VLOG(2) << "Multiple values found for " << property_name << " property.";
     return "";
   }
   return absl::string_view(prop->value, prop->value_length);
@@ -120,7 +120,7 @@ std::vector<absl::string_view> GetAuthPropertyArray(grpc_auth_context* context,
     prop = grpc_auth_property_iterator_next(&it);
   }
   if (values.empty()) {
-    gpr_log(GPR_DEBUG, "No value found for %s property.", property_name);
+    VLOG(2) << "No value found for " << property_name << " property.";
   }
   return values;
 }

data/src/core/lib/security/credentials/xds/xds_credentials.cc

@@ -27,12 +27,12 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 #include "src/core/lib/security/credentials/tls/tls_credentials.h"
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/load_balancing/xds/xds_channel_args.h"
+#include "src/core/util/useful.h"
 #include "src/core/xds/grpc/xds_certificate_provider.h"
 
 namespace grpc_core {

data/src/core/lib/security/security_connector/alts/alts_security_connector.cc

@@ -24,6 +24,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -33,7 +34,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
@@ -187,8 +187,7 @@ namespace internal {
 RefCountedPtr<grpc_auth_context> grpc_alts_auth_context_from_tsi_peer(
     const tsi_peer* peer) {
   if (peer == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid arguments to grpc_alts_auth_context_from_tsi_peer()");
+    LOG(ERROR) << "Invalid arguments to grpc_alts_auth_context_from_tsi_peer()";
     return nullptr;
   }
   // Validate certificate type.
@@ -197,21 +196,21 @@ RefCountedPtr<grpc_auth_context> grpc_alts_auth_context_from_tsi_peer(
   if (cert_type_prop == nullptr ||
       strncmp(cert_type_prop->value.data, TSI_ALTS_CERTIFICATE_TYPE,
               cert_type_prop->value.length) != 0) {
-    gpr_log(GPR_ERROR, "Invalid or missing certificate type property.");
+    LOG(ERROR) << "Invalid or missing certificate type property.";
     return nullptr;
   }
   // Check if security level exists.
   const tsi_peer_property* security_level_prop =
       tsi_peer_get_property_by_name(peer, TSI_SECURITY_LEVEL_PEER_PROPERTY);
   if (security_level_prop == nullptr) {
-    gpr_log(GPR_ERROR, "Missing security level property.");
+    LOG(ERROR) << "Missing security level property.";
     return nullptr;
   }
   // Validate RPC protocol versions.
   const tsi_peer_property* rpc_versions_prop =
       tsi_peer_get_property_by_name(peer, TSI_ALTS_RPC_VERSIONS);
   if (rpc_versions_prop == nullptr) {
-    gpr_log(GPR_ERROR, "Missing rpc protocol versions property.");
+    LOG(ERROR) << "Missing rpc protocol versions property.";
     return nullptr;
   }
   grpc_gcp_rpc_protocol_versions local_versions, peer_versions;
@@ -222,21 +221,21 @@ RefCountedPtr<grpc_auth_context> grpc_alts_auth_context_from_tsi_peer(
       grpc_gcp_rpc_protocol_versions_decode(slice, &peer_versions);
   CSliceUnref(slice);
   if (!decode_result) {
-    gpr_log(GPR_ERROR, "Invalid peer rpc protocol versions.");
+    LOG(ERROR) << "Invalid peer rpc protocol versions.";
     return nullptr;
   }
   // TODO(unknown): Pass highest common rpc protocol version to grpc caller.
   bool check_result = grpc_gcp_rpc_protocol_versions_check(
       &local_versions, &peer_versions, nullptr);
   if (!check_result) {
-    gpr_log(GPR_ERROR, "Mismatch of local and peer rpc protocol versions.");
+    LOG(ERROR) << "Mismatch of local and peer rpc protocol versions.";
     return nullptr;
   }
   // Validate ALTS Context.
   const tsi_peer_property* alts_context_prop =
       tsi_peer_get_property_by_name(peer, TSI_ALTS_CONTEXT);
   if (alts_context_prop == nullptr) {
-    gpr_log(GPR_ERROR, "Missing alts context property.");
+    LOG(ERROR) << "Missing alts context property.";
     return nullptr;
   }
   // Create auth context.
@@ -269,7 +268,7 @@ RefCountedPtr<grpc_auth_context> grpc_alts_auth_context_from_tsi_peer(
     }
   }
   if (!grpc_auth_context_peer_is_authenticated(ctx.get())) {
-    gpr_log(GPR_ERROR, "Invalid unauthenticated peer.");
+    LOG(ERROR) << "Invalid unauthenticated peer.";
     ctx.reset(DEBUG_LOCATION, "test");
     return nullptr;
   }
@@ -285,9 +284,8 @@ grpc_alts_channel_security_connector_create(
     grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
     const char* target_name) {
   if (channel_creds == nullptr || target_name == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Invalid arguments to grpc_alts_channel_security_connector_create()");
+    LOG(ERROR)
+        << "Invalid arguments to grpc_alts_channel_security_connector_create()";
     return nullptr;
   }
   return grpc_core::MakeRefCounted<grpc_alts_channel_security_connector>(
@@ -298,9 +296,8 @@ grpc_core::RefCountedPtr<grpc_server_security_connector>
 grpc_alts_server_security_connector_create(
     grpc_core::RefCountedPtr<grpc_server_credentials> server_creds) {
   if (server_creds == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Invalid arguments to grpc_alts_server_security_connector_create()");
+    LOG(ERROR)
+        << "Invalid arguments to grpc_alts_server_security_connector_create()";
     return nullptr;
   }
   return grpc_core::MakeRefCounted<grpc_alts_server_security_connector>(

data/src/core/lib/security/security_connector/fake/fake_security_connector.cc

@@ -25,6 +25,7 @@
 #include <utility>
 
 #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"
@@ -41,8 +42,6 @@
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/security/security_handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -60,6 +59,8 @@
 #include "src/core/load_balancing/grpclb/grpclb.h"
 #include "src/core/tsi/fake_transport_security.h"
 #include "src/core/tsi/transport_security_interface.h"
+#include "src/core/util/string.h"
+#include "src/core/util/useful.h"
 
 namespace {
 class grpc_fake_channel_security_connector final
@@ -165,28 +166,30 @@ class grpc_fake_channel_security_connector final
     gpr_string_split(expected_targets_->c_str(), ";", &lbs_and_backends,
                      &lbs_and_backends_size);
     if (lbs_and_backends_size > 2 || lbs_and_backends_size == 0) {
-      gpr_log(GPR_ERROR, "Invalid expected targets arg value: '%s'",
-              expected_targets_->c_str());
+      LOG(ERROR) << "Invalid expected targets arg value: '"
+                 << expected_targets_->c_str() << "'";
       goto done;
     }
     if (is_lb_channel_) {
       if (lbs_and_backends_size != 2) {
-        gpr_log(GPR_ERROR,
-                "Invalid expected targets arg value: '%s'. Expectations for LB "
-                "channels must be of the form 'be1,be2,be3,...;lb1,lb2,...",
-                expected_targets_->c_str());
+        LOG(ERROR) << "Invalid expected targets arg value: '"
+                   << expected_targets_->c_str()
+                   << "'. Expectations for LB channels must be of the form "
+                      "'be1,be2,be3,...;lb1,lb2,...";
         goto done;
       }
       if (!fake_check_target(target_, lbs_and_backends[1])) {
-        gpr_log(GPR_ERROR, "LB target '%s' not found in expected set '%s'",
-                target_, lbs_and_backends[1]);
+        LOG(ERROR) << "LB target '" << target_
+                   << "' not found in expected set '" << lbs_and_backends[1]
+                   << "'";
         goto done;
       }
       success = true;
     } else {
       if (!fake_check_target(target_, lbs_and_backends[0])) {
-        gpr_log(GPR_ERROR, "Backend target '%s' not found in expected set '%s'",
-                target_, lbs_and_backends[0]);
+        LOG(ERROR) << "Backend target '" << target_
+                   << "' not found in expected set '" << lbs_and_backends[0]
+                   << "'";
         goto done;
       }
       success = true;