grpc 1.63.0 → 1.65.2

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 #include <stdint.h>
@@ -25,10 +23,13 @@
 #include <utility>
 #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>
 
 #include "src/core/lib/debug/trace.h"
@@ -122,21 +123,21 @@ 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.
-  GPR_ASSERT(private_key_path_.empty() == identity_certificate_path_.empty());
+  CHECK(private_key_path_.empty() == identity_certificate_path_.empty());
   // Must be watching either root or identity certs.
-  GPR_ASSERT(!private_key_path_.empty() || !root_cert_path_.empty());
+  CHECK(!private_key_path_.empty() || !root_cert_path_.empty());
   gpr_event_init(&shutdown_event_);
   ForceUpdate();
   auto thread_lambda = [](void* arg) {
     FileWatcherCertificateProvider* provider =
         static_cast<FileWatcherCertificateProvider*>(arg);
-    GPR_ASSERT(provider != nullptr);
+    CHECK_NE(provider, nullptr);
     while (true) {
       void* value = gpr_event_wait(
           &provider->shutdown_event_,
@@ -283,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());
@@ -315,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());
@@ -353,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;
 }
 
@@ -386,7 +378,7 @@ int64_t FileWatcherCertificateProvider::TestOnlyGetRefreshIntervalSecond()
 
 grpc_tls_certificate_provider* grpc_tls_certificate_provider_static_data_create(
     const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs) {
-  GPR_ASSERT(root_certificate != nullptr || pem_key_cert_pairs != nullptr);
+  CHECK(root_certificate != nullptr || pem_key_cert_pairs != nullptr);
   grpc_core::ExecCtx exec_ctx;
   grpc_core::PemKeyCertPairList identity_pairs_core;
   if (pem_key_cert_pairs != nullptr) {

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

@@ -17,23 +17,22 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_PROVIDER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_PROVIDER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <map>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
+#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
@@ -66,7 +66,7 @@ struct grpc_tls_certificate_provider
   // be reused when two different `grpc_tls_certificate_provider` objects are
   // used but they compare as equal (assuming other channel args match).
   int Compare(const grpc_tls_certificate_provider* other) const {
-    GPR_ASSERT(other != nullptr);
+    CHECK_NE(other, nullptr);
     int r = type().Compare(other->type());
     if (r != 0) return r;
     return CompareImpl(other);

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h"
 
 #include <string.h>
@@ -23,10 +21,12 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/strings/string_view.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/debug/trace.h"
@@ -112,7 +112,7 @@ UniqueTypeName NoOpCertificateVerifier::type() const {
 bool HostNameCertificateVerifier::Verify(
     grpc_tls_custom_verification_check_request* request,
     std::function<void(absl::Status)>, absl::Status* sync_status) {
-  GPR_ASSERT(request != nullptr);
+  CHECK_NE(request, nullptr);
   // Extract the target name, and remove its port.
   const char* target_name = request->target_name;
   if (target_name == nullptr) {

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

@@ -17,22 +17,23 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_VERIFIER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_VERIFIER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <map>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 #include <grpc/status.h>
 #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
@@ -58,7 +59,7 @@ struct grpc_tls_certificate_verifier
   // If this method returns 0, it means that gRPC can treat the two certificate
   // verifiers as effectively the same.
   int Compare(const grpc_tls_certificate_verifier* other) const {
-    GPR_ASSERT(other != nullptr);
+    CHECK_NE(other, nullptr);
     int r = type().Compare(other->type());
     if (r != 0) return r;
     return CompareImpl(other);

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

@@ -16,14 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 
 #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"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -40,7 +41,7 @@ grpc_tls_credentials_options* grpc_tls_credentials_options_create() {
 
 grpc_tls_credentials_options* grpc_tls_credentials_options_copy(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   return new grpc_tls_credentials_options(*options);
 }
 
@@ -52,21 +53,21 @@ void grpc_tls_credentials_options_destroy(
 void grpc_tls_credentials_options_set_cert_request_type(
     grpc_tls_credentials_options* options,
     grpc_ssl_client_certificate_request_type type) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_cert_request_type(type);
 }
 
 void grpc_tls_credentials_options_set_verify_server_cert(
     grpc_tls_credentials_options* options, int verify_server_cert) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_verify_server_cert(verify_server_cert);
 }
 
 void grpc_tls_credentials_options_set_certificate_provider(
     grpc_tls_credentials_options* options,
     grpc_tls_certificate_provider* provider) {
-  GPR_ASSERT(options != nullptr);
-  GPR_ASSERT(provider != nullptr);
+  CHECK_NE(options, nullptr);
+  CHECK_NE(provider, nullptr);
   grpc_core::ExecCtx exec_ctx;
   options->set_certificate_provider(
       provider->Ref(DEBUG_LOCATION, "set_certificate_provider"));
@@ -74,45 +75,45 @@ void grpc_tls_credentials_options_set_certificate_provider(
 
 void grpc_tls_credentials_options_watch_root_certs(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_watch_root_cert(true);
 }
 
 void grpc_tls_credentials_options_set_root_cert_name(
     grpc_tls_credentials_options* options, const char* root_cert_name) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_root_cert_name(root_cert_name);
 }
 
 void grpc_tls_credentials_options_watch_identity_key_cert_pairs(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_watch_identity_pair(true);
 }
 
 void grpc_tls_credentials_options_set_identity_cert_name(
     grpc_tls_credentials_options* options, const char* identity_cert_name) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_identity_cert_name(identity_cert_name);
 }
 
 void grpc_tls_credentials_options_set_certificate_verifier(
     grpc_tls_credentials_options* options,
     grpc_tls_certificate_verifier* verifier) {
-  GPR_ASSERT(options != nullptr);
-  GPR_ASSERT(verifier != nullptr);
+  CHECK_NE(options, nullptr);
+  CHECK_NE(verifier, nullptr);
   options->set_certificate_verifier(verifier->Ref());
 }
 
 void grpc_tls_credentials_options_set_crl_directory(
     grpc_tls_credentials_options* options, const char* crl_directory) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_crl_directory(crl_directory);
 }
 
 void grpc_tls_credentials_options_set_check_call_host(
     grpc_tls_credentials_options* options, int check_call_host) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_check_call_host(check_call_host);
 }
 
@@ -127,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 : "");
 }
@@ -146,18 +147,18 @@ void grpc_tls_credentials_options_set_send_client_ca_list(
 void grpc_tls_credentials_options_set_crl_provider(
     grpc_tls_credentials_options* options,
     std::shared_ptr<grpc_core::experimental::CrlProvider> provider) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_crl_provider(provider);
 }
 
 void grpc_tls_credentials_options_set_min_tls_version(
     grpc_tls_credentials_options* options, grpc_tls_version min_tls_version) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_min_tls_version(min_tls_version);
 }
 
 void grpc_tls_credentials_options_set_max_tls_version(
     grpc_tls_credentials_options* options, grpc_tls_version max_tls_version) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_max_tls_version(max_tls_version);
 }

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

@@ -25,6 +25,7 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"

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

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_crl_provider.h"
 
 #include <limits.h>
 
+#include <grpc/support/port_platform.h>
+
 // IWYU pragma: no_include <ratio>
 #include <memory>
 #include <type_traits>
@@ -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/grpc_tls_crl_provider.h

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CRL_PROVIDER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CRL_PROVIDER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <chrono>
 #include <functional>
 #include <memory>
@@ -39,6 +37,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc_crl_provider.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/directory_reader.h"
 #include "src/core/lib/gprpp/sync.h"

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

@@ -16,56 +16,54 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/tls_credentials.h"
 
 #include <memory>
 #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.
@@ -74,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_credentials.h

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
 
-#include <grpc/support/port_platform.h>
-
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

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

@@ -16,19 +16,18 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
 
 #include <stddef.h>
 
 #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 {
 
@@ -100,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);
@@ -121,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/tls/tls_utils.h

@@ -19,14 +19,13 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_UTILS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {