grpc 1.63.0 → 1.66.0

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
 
 #include <functional>
@@ -21,10 +19,11 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -37,11 +36,10 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_authz_trace(false, "grpc_authz_api");
-
 const NoInterceptor GrpcServerAuthzFilter::Call::OnServerInitialMetadata;
 const NoInterceptor GrpcServerAuthzFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor GrpcServerAuthzFilter::Call::OnClientToServerMessage;
+const NoInterceptor GrpcServerAuthzFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor GrpcServerAuthzFilter::Call::OnServerToClientMessage;
 const NoInterceptor GrpcServerAuthzFilter::Call::OnFinalize;
 
@@ -52,29 +50,26 @@ GrpcServerAuthzFilter::GrpcServerAuthzFilter(
       per_channel_evaluate_args_(auth_context_.get(), args),
       provider_(std::move(provider)) {}
 
-absl::StatusOr<GrpcServerAuthzFilter> GrpcServerAuthzFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
+absl::StatusOr<std::unique_ptr<GrpcServerAuthzFilter>>
+GrpcServerAuthzFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
   auto* auth_context = args.GetObject<grpc_auth_context>();
   auto* provider = args.GetObject<grpc_authorization_policy_provider>();
   if (provider == nullptr) {
     return absl::InvalidArgumentError("Failed to get authorization provider.");
   }
-  return GrpcServerAuthzFilter(
+  return std::make_unique<GrpcServerAuthzFilter>(
       auth_context != nullptr ? auth_context->Ref() : nullptr, args,
       provider->Ref());
 }
 
 bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
   EvaluateArgs args(&initial_metadata, &per_channel_evaluate_args_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_trace)) {
-    gpr_log(GPR_DEBUG,
-            "checking request: url_path=%s, transport_security_type=%s, "
-            "uri_sans=[%s], dns_sans=[%s], subject=%s",
-            std::string(args.GetPath()).c_str(),
-            std::string(args.GetTransportSecurityType()).c_str(),
-            absl::StrJoin(args.GetUriSans(), ",").c_str(),
-            absl::StrJoin(args.GetDnsSans(), ",").c_str(),
-            std::string(args.GetSubject()).c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
+    VLOG(2) << "checking request: url_path=" << args.GetPath()
+            << ", transport_security_type=" << args.GetTransportSecurityType()
+            << ", uri_sans=[" << absl::StrJoin(args.GetUriSans(), ",")
+            << "], dns_sans=[" << absl::StrJoin(args.GetDnsSans(), ",")
+            << "], subject=" << args.GetSubject();
   }
   grpc_authorization_policy_provider::AuthorizationEngines engines =
       provider_->engines();
@@ -82,9 +77,9 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
     AuthorizationEngine::Decision decision =
         engines.deny_engine->Evaluate(args);
     if (decision.type == AuthorizationEngine::Decision::Type::kDeny) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_trace)) {
-        gpr_log(GPR_INFO, "chand=%p: request denied by policy %s.", this,
-                decision.matching_policy_name.c_str());
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
+        LOG(INFO) << "chand=" << this << ": request denied by policy "
+                  << decision.matching_policy_name;
       }
       return false;
     }
@@ -93,16 +88,16 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
     AuthorizationEngine::Decision decision =
         engines.allow_engine->Evaluate(args);
     if (decision.type == AuthorizationEngine::Decision::Type::kAllow) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_trace)) {
-        gpr_log(GPR_DEBUG, "chand=%p: request allowed by policy %s.", this,
-                decision.matching_policy_name.c_str());
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
+        VLOG(2) << "chand=" << this << ": request allowed by policy "
+                << decision.matching_policy_name;
       }
       return true;
     }
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_trace)) {
-    gpr_log(GPR_INFO, "chand=%p: request denied, no matching policy found.",
-            this);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
+    LOG(INFO) << "chand=" << this
+              << ": request denied, no matching policy found.";
   }
   return false;
 }
@@ -116,7 +111,6 @@ absl::Status GrpcServerAuthzFilter::Call::OnClientInitialMetadata(
 }
 
 const grpc_channel_filter GrpcServerAuthzFilter::kFilter =
-    MakePromiseBasedFilter<GrpcServerAuthzFilter, FilterEndpoint::kServer>(
-        "grpc-server-authz");
+    MakePromiseBasedFilter<GrpcServerAuthzFilter, FilterEndpoint::kServer>();
 
 }  // namespace grpc_core

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -15,11 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_GRPC_SERVER_AUTHZ_FILTER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_GRPC_SERVER_AUTHZ_FILTER_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/status/statusor.h"
 
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -38,8 +37,14 @@ class GrpcServerAuthzFilter final
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<GrpcServerAuthzFilter> Create(const ChannelArgs& args,
-                                                      ChannelFilter::Args);
+  static absl::string_view TypeName() { return "grpc-server-authz"; }
+
+  static absl::StatusOr<std::unique_ptr<GrpcServerAuthzFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
+
+  GrpcServerAuthzFilter(
+      RefCountedPtr<grpc_auth_context> auth_context, const ChannelArgs& args,
+      RefCountedPtr<grpc_authorization_policy_provider> provider);
 
   class Call {
    public:
@@ -48,15 +53,12 @@ class GrpcServerAuthzFilter final
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
 
  private:
-  GrpcServerAuthzFilter(
-      RefCountedPtr<grpc_auth_context> auth_context, const ChannelArgs& args,
-      RefCountedPtr<grpc_authorization_policy_provider> provider);
-
   bool IsAuthorized(ClientMetadata& initial_metadata);
 
   RefCountedPtr<grpc_auth_context> auth_context_;

data/src/core/lib/security/authorization/matchers.cc

@@ -12,20 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/authorization/matchers.h"
 
 #include <string.h>
 
 #include <string>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security_constants.h>
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -158,8 +157,8 @@ IpAuthorizationMatcher::IpAuthorizationMatcher(Type type, Rbac::CidrRange range)
   auto address =
       StringToSockaddr(range.address_prefix, 0);  // Port does not matter here.
   if (!address.ok()) {
-    gpr_log(GPR_DEBUG, "CidrRange address \"%s\" is not IPv4/IPv6. Error: %s",
-            range.address_prefix.c_str(), address.status().ToString().c_str());
+    VLOG(2) << "CidrRange address \"" << range.address_prefix
+            << "\" is not IPv4/IPv6. Error: " << address.status();
     memset(&subnet_address_, 0, sizeof(subnet_address_));
     return;
   }

data/src/core/lib/security/authorization/matchers.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_MATCHERS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_MATCHERS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <memory>
@@ -25,6 +23,8 @@
 
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/matchers/matchers.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"

data/src/core/lib/security/authorization/rbac_policy.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/authorization/rbac_policy.h"
 
 #include <utility>
@@ -22,6 +20,8 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 //

data/src/core/lib/security/authorization/rbac_policy.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_RBAC_POLICY_H
 #define GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_RBAC_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <map>
@@ -27,6 +25,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_audit_logging.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/matchers/matchers.h"
 

data/src/core/lib/security/authorization/stdout_logger.cc

@@ -12,14 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/authorization/stdout_logger.h"
 
 #include <cstdio>
 #include <memory>
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -29,6 +28,7 @@
 #include <grpc/grpc_audit_logging.h>
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 namespace experimental {
@@ -66,7 +66,8 @@ StdoutAuditLoggerFactory::ParseAuditLoggerConfig(const Json&) {
 std::unique_ptr<AuditLogger> StdoutAuditLoggerFactory::CreateAuditLogger(
     std::unique_ptr<AuditLoggerFactory::Config> config) {
   // Sanity check.
-  GPR_ASSERT(config != nullptr && config->name() == name());
+  CHECK(config != nullptr);
+  CHECK(config->name() == name());
   return std::make_unique<StdoutAuditLogger>();
 }
 

data/src/core/lib/security/authorization/stdout_logger.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_STDOUT_LOGGER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_STDOUT_LOGGER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <string>
 
@@ -25,6 +23,7 @@
 
 #include <grpc/grpc_audit_logging.h>
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 namespace experimental {

data/src/core/lib/security/certificate_provider/certificate_provider_factory.h

@@ -19,19 +19,19 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_FACTORY_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_FACTORY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/certificate_provider/certificate_provider_registry.cc

@@ -16,23 +16,23 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 
 #include <string>
 #include <utility>
 
-#include <grpc/support/log.h>
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
 void CertificateProviderRegistry::Builder::RegisterCertificateProviderFactory(
     std::unique_ptr<CertificateProviderFactory> factory) {
   absl::string_view name = factory->name();
-  gpr_log(GPR_DEBUG, "registering certificate provider factory for \"%s\"",
-          std::string(name).c_str());
-  GPR_ASSERT(factories_.emplace(name, std::move(factory)).second);
+  VLOG(2) << "registering certificate provider factory for \"" << name << "\"";
+  CHECK(factories_.emplace(name, std::move(factory)).second);
 }
 
 CertificateProviderRegistry CertificateProviderRegistry::Builder::Build() {

data/src/core/lib/security/certificate_provider/certificate_provider_registry.h

@@ -19,14 +19,14 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_REGISTRY_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_REGISTRY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/security/certificate_provider/certificate_provider_factory.h"
 
 namespace grpc_core {

data/src/core/lib/security/context/security_context.cc

@@ -16,49 +16,47 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/context/security_context.h"
 
 #include <string.h>
 
 #include <algorithm>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.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/channel/context.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 
-grpc_core::DebugOnlyTraceFlag grpc_trace_auth_context_refcount(
-    false, "auth_context_refcount");
-
 // --- grpc_call ---
 
 grpc_call_error grpc_call_set_credentials(grpc_call* call,
                                           grpc_call_credentials* creds) {
   grpc_core::ExecCtx exec_ctx;
   grpc_client_security_context* ctx = nullptr;
-  GRPC_API_TRACE("grpc_call_set_credentials(call=%p, creds=%p)", 2,
-                 (call, creds));
+  GRPC_TRACE_LOG(api, INFO) << "grpc_call_set_credentials(call=" << call
+                            << ", creds=" << creds << ")";
   if (!grpc_call_is_client(call)) {
-    gpr_log(GPR_ERROR, "Method is client-side only.");
+    LOG(ERROR) << "Method is client-side only.";
     return GRPC_CALL_ERROR_NOT_ON_SERVER;
   }
-  ctx = static_cast<grpc_client_security_context*>(
-      grpc_call_context_get(call, GRPC_CONTEXT_SECURITY));
+  auto* arena = grpc_call_get_arena(call);
+  ctx = grpc_core::DownCast<grpc_client_security_context*>(
+      arena->GetContext<grpc_core::SecurityContext>());
   if (ctx == nullptr) {
-    ctx = grpc_client_security_context_create(grpc_call_get_arena(call), creds);
-    grpc_call_context_set(call, GRPC_CONTEXT_SECURITY, ctx,
-                          grpc_client_security_context_destroy);
+    ctx = grpc_client_security_context_create(arena, creds);
+    arena->SetContext<grpc_core::SecurityContext>(ctx);
   } else {
     ctx->creds = creds != nullptr ? creds->Ref() : nullptr;
   }
@@ -67,11 +65,12 @@ grpc_call_error grpc_call_set_credentials(grpc_call* call,
 }
 
 grpc_auth_context* grpc_call_auth_context(grpc_call* call) {
-  void* sec_ctx = grpc_call_context_get(call, GRPC_CONTEXT_SECURITY);
-  GRPC_API_TRACE("grpc_call_auth_context(call=%p)", 1, (call));
+  auto* sec_ctx =
+      grpc_call_get_arena(call)->GetContext<grpc_core::SecurityContext>();
+  GRPC_TRACE_LOG(api, INFO) << "grpc_call_auth_context(call=" << call << ")";
   if (sec_ctx == nullptr) return nullptr;
   if (grpc_call_is_client(call)) {
-    auto* sc = static_cast<grpc_client_security_context*>(sec_ctx);
+    auto* sc = grpc_core::DownCast<grpc_client_security_context*>(sec_ctx);
     if (sc->auth_context == nullptr) {
       return nullptr;
     } else {
@@ -80,7 +79,7 @@ grpc_auth_context* grpc_call_auth_context(grpc_call* call) {
           .release();
     }
   } else {
-    auto* sc = static_cast<grpc_server_security_context*>(sec_ctx);
+    auto* sc = grpc_core::DownCast<grpc_server_security_context*>(sec_ctx);
     if (sc->auth_context == nullptr) {
       return nullptr;
     } else {
@@ -92,7 +91,8 @@ grpc_auth_context* grpc_call_auth_context(grpc_call* call) {
 }
 
 void grpc_auth_context_release(grpc_auth_context* context) {
-  GRPC_API_TRACE("grpc_auth_context_release(context=%p)", 1, (context));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_release(context=" << context << ")";
   if (context == nullptr) return;
   context->Unref(DEBUG_LOCATION, "grpc_auth_context_unref");
 }
@@ -142,8 +142,8 @@ static grpc_auth_property_iterator empty_iterator = {nullptr, 0, nullptr};
 
 const char* grpc_auth_context_peer_identity_property_name(
     const grpc_auth_context* ctx) {
-  GRPC_API_TRACE("grpc_auth_context_peer_identity_property_name(ctx=%p)", 1,
-                 (ctx));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_peer_identity_property_name(ctx=" << ctx << ")";
   return ctx->peer_identity_property_name();
 }
 
@@ -152,12 +152,12 @@ int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context* ctx,
   grpc_auth_property_iterator it =
       grpc_auth_context_find_properties_by_name(ctx, name);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
-  GRPC_API_TRACE(
-      "grpc_auth_context_set_peer_identity_property_name(ctx=%p, name=%s)", 2,
-      (ctx, name));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_set_peer_identity_property_name(ctx=" << ctx
+      << ", name=" << name << ")";
   if (prop == nullptr) {
-    gpr_log(GPR_ERROR, "Property name %s not found in auth context.",
-            name != nullptr ? name : "NULL");
+    LOG(ERROR) << "Property name " << (name != nullptr ? name : "NULL")
+               << " not found in auth context.";
     return 0;
   }
   ctx->set_peer_identity_property_name(prop->name);
@@ -165,14 +165,16 @@ int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context* ctx,
 }
 
 int grpc_auth_context_peer_is_authenticated(const grpc_auth_context* ctx) {
-  GRPC_API_TRACE("grpc_auth_context_peer_is_authenticated(ctx=%p)", 1, (ctx));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_peer_is_authenticated(ctx=" << ctx << ")";
   return ctx->is_authenticated();
 }
 
 grpc_auth_property_iterator grpc_auth_context_property_iterator(
     const grpc_auth_context* ctx) {
   grpc_auth_property_iterator it = empty_iterator;
-  GRPC_API_TRACE("grpc_auth_context_property_iterator(ctx=%p)", 1, (ctx));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_property_iterator(ctx=" << ctx << ")";
   if (ctx == nullptr) return it;
   it.ctx = ctx;
   return it;
@@ -180,7 +182,8 @@ grpc_auth_property_iterator grpc_auth_context_property_iterator(
 
 const grpc_auth_property* grpc_auth_property_iterator_next(
     grpc_auth_property_iterator* it) {
-  GRPC_API_TRACE("grpc_auth_property_iterator_next(it=%p)", 1, (it));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_property_iterator_next(it=" << it << ")";
   if (it == nullptr || it->ctx == nullptr) return nullptr;
   while (it->index == it->ctx->properties().count) {
     if (it->ctx->chained() == nullptr) return nullptr;
@@ -193,7 +196,7 @@ const grpc_auth_property* grpc_auth_property_iterator_next(
     while (it->index < it->ctx->properties().count) {
       const grpc_auth_property* prop =
           &it->ctx->properties().array[it->index++];
-      GPR_ASSERT(prop->name != nullptr);
+      CHECK_NE(prop->name, nullptr);
       if (strcmp(it->name, prop->name) == 0) {
         return prop;
       }
@@ -206,8 +209,9 @@ const grpc_auth_property* grpc_auth_property_iterator_next(
 grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
     const grpc_auth_context* ctx, const char* name) {
   grpc_auth_property_iterator it = empty_iterator;
-  GRPC_API_TRACE("grpc_auth_context_find_properties_by_name(ctx=%p, name=%s)",
-                 2, (ctx, name));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_find_properties_by_name(ctx=" << ctx
+      << ", name=" << name << ")";
   if (ctx == nullptr || name == nullptr) return empty_iterator;
   it.ctx = ctx;
   it.name = name;
@@ -216,7 +220,8 @@ grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
 
 grpc_auth_property_iterator grpc_auth_context_peer_identity(
     const grpc_auth_context* ctx) {
-  GRPC_API_TRACE("grpc_auth_context_peer_identity(ctx=%p)", 1, (ctx));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_peer_identity(ctx=" << ctx << ")";
   if (ctx == nullptr) return empty_iterator;
   return grpc_auth_context_find_properties_by_name(
       ctx, ctx->peer_identity_property_name());
@@ -246,12 +251,11 @@ void grpc_auth_context::add_property(const char* name, const char* value,
 
 void grpc_auth_context_add_property(grpc_auth_context* ctx, const char* name,
                                     const char* value, size_t value_length) {
-  GRPC_API_TRACE(
+  GRPC_TRACE_LOG(api, INFO) << absl::StrFormat(
       "grpc_auth_context_add_property(ctx=%p, name=%s, value=%*.*s, "
       "value_length=%lu)",
-      6,
-      (ctx, name, (int)value_length, (int)value_length, value,
-       (unsigned long)value_length));
+      ctx, name, (int)value_length, (int)value_length, value,
+      (unsigned long)value_length);
   ctx->add_property(name, value, value_length);
 }
 
@@ -267,9 +271,9 @@ void grpc_auth_context::add_cstring_property(const char* name,
 void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx,
                                             const char* name,
                                             const char* value) {
-  GRPC_API_TRACE(
-      "grpc_auth_context_add_cstring_property(ctx=%p, name=%s, value=%s)", 3,
-      (ctx, name, value));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_auth_context_add_cstring_property(ctx=" << ctx
+      << ", name=" << name << ", value=" << value << ")";
   ctx->add_cstring_property(name, value);
 }
 
@@ -310,8 +314,8 @@ grpc_arg grpc_auth_context_to_arg(grpc_auth_context* c) {
 grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg) {
   if (strcmp(arg->key, GRPC_AUTH_CONTEXT_ARG) != 0) return nullptr;
   if (arg->type != GRPC_ARG_POINTER) {
-    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
-            GRPC_AUTH_CONTEXT_ARG);
+    LOG(ERROR) << "Invalid type " << arg->type << " for arg "
+               << GRPC_AUTH_CONTEXT_ARG;
     return nullptr;
   }
   return static_cast<grpc_auth_context*>(arg->value.pointer.p);