grpc 1.65.2 → 1.66.0

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

@@ -40,7 +40,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
 
@@ -123,9 +122,9 @@ FileWatcherCertificateProvider::FileWatcherCertificateProvider(
       refresh_interval_sec_(refresh_interval_sec),
       distributor_(MakeRefCounted<grpc_tls_certificate_distributor>()) {
   if (refresh_interval_sec_ < kMinimumFileWatcherRefreshIntervalSeconds) {
-    LOG(INFO) << "FileWatcherCertificateProvider refresh_interval_sec_ set to "
-                 "value less than minimum. Overriding configured value to "
-                 "minimum.";
+    VLOG(2) << "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.
@@ -406,8 +405,8 @@ grpc_tls_certificate_provider_file_watcher_create(
 
 void grpc_tls_certificate_provider_release(
     grpc_tls_certificate_provider* provider) {
-  GRPC_API_TRACE("grpc_tls_certificate_provider_release(provider=%p)", 1,
-                 (provider));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_tls_certificate_provider_release(provider=" << provider << ")";
   grpc_core::ExecCtx exec_ctx;
   if (provider != nullptr) provider->Unref();
 }

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

@@ -33,7 +33,6 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
-#include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
 
@@ -234,8 +233,8 @@ grpc_tls_certificate_verifier_host_name_create() {
 
 void grpc_tls_certificate_verifier_release(
     grpc_tls_certificate_verifier* verifier) {
-  GRPC_API_TRACE("grpc_tls_certificate_verifier_release(verifier=%p)", 1,
-                 (verifier));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_tls_certificate_verifier_release(verifier=" << verifier << ")";
   grpc_core::ExecCtx exec_ctx;
   if (verifier != nullptr) verifier->Unref();
 }

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

@@ -29,7 +29,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/tsi/ssl_transport_security.h"
 
 /// -- Wrapper APIs declared in grpc_security.h -- *
@@ -122,16 +121,15 @@ void grpc_tls_credentials_options_set_tls_session_key_log_file_path(
   if (!tsi_tls_session_key_logging_supported() || options == nullptr) {
     return;
   }
-  GRPC_API_TRACE(
-      "grpc_tls_credentials_options_set_tls_session_key_log_config(options=%p)",
-      1, (options));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_tls_credentials_options_set_tls_session_key_log_config(options="
+      << options << ")";
   // Tls session key logging is assumed to be enabled if the specified log
   // file is non-empty.
   if (path != nullptr) {
-    LOG(INFO) << "Enabling TLS session key logging with keys stored at: "
-              << path;
+    VLOG(2) << "Enabling TLS session key logging with keys stored at: " << path;
   } else {
-    LOG(INFO) << "Disabling TLS session key logging";
+    VLOG(2) << "Disabling TLS session key logging";
   }
   options->set_tls_session_key_log_file_path(path != nullptr ? path : "");
 }

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

@@ -84,8 +84,8 @@ bool CredentialOptionSanityCheck(grpc_tls_credentials_options* options,
     // 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.
-    LOG(INFO) << "No verifier specified on the client side. Using default "
-                 "hostname verifier";
+    VLOG(2) << "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/xds/xds_credentials.cc

@@ -142,18 +142,22 @@ XdsCredentials::create_security_connector(
   auto xds_certificate_provider = args->GetObjectRef<XdsCertificateProvider>();
   if (xds_certificate_provider != nullptr) {
     const bool watch_root = xds_certificate_provider->ProvidesRootCerts();
+    const bool use_system_root_certs =
+        xds_certificate_provider->UseSystemRootCerts();
     const bool watch_identity =
         xds_certificate_provider->ProvidesIdentityCerts();
-    if (watch_root || watch_identity) {
+    if (watch_root || use_system_root_certs || watch_identity) {
       auto tls_credentials_options =
           MakeRefCounted<grpc_tls_credentials_options>();
-      tls_credentials_options->set_certificate_provider(
-          xds_certificate_provider);
-      if (watch_root) {
-        tls_credentials_options->set_watch_root_cert(true);
-      }
-      if (watch_identity) {
-        tls_credentials_options->set_watch_identity_pair(true);
+      if (watch_root || watch_identity) {
+        tls_credentials_options->set_certificate_provider(
+            xds_certificate_provider);
+        if (watch_root) {
+          tls_credentials_options->set_watch_root_cert(true);
+        }
+        if (watch_identity) {
+          tls_credentials_options->set_watch_identity_pair(true);
+        }
       }
       tls_credentials_options->set_verify_server_cert(true);
       tls_credentials_options->set_certificate_verifier(

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

@@ -23,8 +23,8 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -105,8 +105,8 @@ grpc_arg grpc_security_connector_to_arg(grpc_security_connector* sc) {
 grpc_security_connector* grpc_security_connector_from_arg(const grpc_arg* arg) {
   if (strcmp(arg->key, GRPC_ARG_SECURITY_CONNECTOR) != 0) return nullptr;
   if (arg->type != GRPC_ARG_POINTER) {
-    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
-            GRPC_ARG_SECURITY_CONNECTOR);
+    LOG(ERROR) << "Invalid type " << arg->type << " for arg "
+               << GRPC_ARG_SECURITY_CONNECTOR;
     return nullptr;
   }
   return static_cast<grpc_security_connector*>(arg->value.pointer.p);

data/src/core/lib/security/security_connector/ssl_utils.cc

@@ -232,16 +232,18 @@ static bool IsSpiffeId(absl::string_view uri) {
     return false;
   };
   if (uri.size() > 2048) {
-    LOG(INFO) << "Invalid SPIFFE ID: ID longer than 2048 bytes.";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "Invalid SPIFFE ID: ID longer than 2048 bytes.";
     return false;
   }
   std::vector<absl::string_view> splits = absl::StrSplit(uri, '/');
   if (splits.size() < 4 || splits[3].empty()) {
-    LOG(INFO) << "Invalid SPIFFE ID: workload id is empty.";
+    GRPC_TRACE_LOG(tsi, INFO) << "Invalid SPIFFE ID: workload id is empty.";
     return false;
   }
   if (splits[2].size() > 255) {
-    LOG(INFO) << "Invalid SPIFFE ID: domain longer than 255 characters.";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "Invalid SPIFFE ID: domain longer than 255 characters.";
     return false;
   }
   return true;
@@ -332,7 +334,7 @@ grpc_core::RefCountedPtr<grpc_auth_context> grpc_ssl_peer_to_auth_context(
                                      GRPC_PEER_SPIFFE_ID_PROPERTY_NAME,
                                      spiffe_data, spiffe_length);
     } else {
-      LOG(INFO) << "Invalid SPIFFE ID: multiple URI SANs.";
+      GRPC_TRACE_LOG(tsi, INFO) << "Invalid SPIFFE ID: multiple URI SANs.";
     }
   }
   return ctx;
@@ -419,8 +421,9 @@ grpc_security_status grpc_ssl_tsi_client_handshaker_factory_init(
   const char* root_certs;
   const tsi_ssl_root_certs_store* root_store;
   if (pem_root_certs == nullptr && !skip_server_certificate_verification) {
-    LOG(INFO) << "No root certificates specified; use ones stored in system "
-                 "default locations instead";
+    GRPC_TRACE_LOG(tsi, INFO)
+        << "No root certificates specified; use ones stored in system "
+           "default locations instead";
     // Use default root certificates.
     root_certs = grpc_core::DefaultSslRootStore::GetPemRootCerts();
     if (root_certs == nullptr) {

data/src/core/lib/security/transport/auth_filters.h

@@ -43,6 +43,8 @@ class ClientAuthFilter final : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "client-auth-filter"; }
+
   ClientAuthFilter(
       RefCountedPtr<grpc_channel_security_connector> security_connector,
       RefCountedPtr<grpc_auth_context> auth_context);
@@ -96,6 +98,8 @@ class ServerAuthFilter final : public ImplementChannelFilter<ServerAuthFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "server-auth"; }
+
   ServerAuthFilter(RefCountedPtr<grpc_server_credentials> server_credentials,
                    RefCountedPtr<grpc_auth_context> auth_context);
 

data/src/core/lib/security/transport/client_auth_filter.cc

@@ -216,7 +216,6 @@ absl::StatusOr<std::unique_ptr<ClientAuthFilter>> ClientAuthFilter::Create(
 }
 
 const grpc_channel_filter ClientAuthFilter::kFilter =
-    MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>(
-        "client-auth-filter");
+    MakePromiseBasedFilter<ClientAuthFilter, FilterEndpoint::kClient>();
 
 }  // namespace grpc_core

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -24,6 +24,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
@@ -32,7 +33,6 @@
 #include <grpc/grpc_security.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -62,8 +62,7 @@
 namespace grpc_core {
 
 const grpc_channel_filter ServerAuthFilter::kFilter =
-    MakePromiseBasedFilter<ServerAuthFilter, FilterEndpoint::kServer>(
-        "server-auth");
+    MakePromiseBasedFilter<ServerAuthFilter, FilterEndpoint::kServer>();
 
 const NoInterceptor ServerAuthFilter::Call::OnClientToServerMessage;
 const NoInterceptor ServerAuthFilter::Call::OnClientToServerHalfClose;
@@ -133,11 +132,10 @@ ServerAuthFilter::RunApplicationCode::RunApplicationCode(
     ServerAuthFilter* filter, ClientMetadata& metadata)
     : state_(GetContext<Arena>()->ManagedNew<State>(metadata)) {
   if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    gpr_log(GPR_ERROR,
-            "%s[server-auth]: Delegate to application: filter=%p this=%p "
-            "auth_ctx=%p",
-            GetContext<Activity>()->DebugTag().c_str(), filter, this,
-            filter->auth_context_.get());
+    LOG(ERROR) << GetContext<Activity>()->DebugTag()
+               << "[server-auth]: Delegate to application: filter=" << filter
+               << " this=" << this
+               << " auth_ctx=" << filter->auth_context_.get();
   }
   filter->server_credentials_->auth_metadata_processor().process(
       filter->server_credentials_->auth_metadata_processor().state,
@@ -163,9 +161,8 @@ void ServerAuthFilter::RunApplicationCode::OnMdProcessingDone(
 
   // TODO(ZhenLian): Implement support for response_md.
   if (response_md != nullptr && num_response_md > 0) {
-    gpr_log(GPR_ERROR,
-            "response_md in auth metadata processing not supported for now. "
-            "Ignoring...");
+    LOG(ERROR) << "response_md in auth metadata processing not supported for "
+                  "now. Ignoring...";
   }
 
   if (status == GRPC_STATUS_OK) {

data/src/core/lib/slice/slice_refcount.h

@@ -20,7 +20,6 @@
 
 #include <atomic>
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -48,16 +47,15 @@ struct grpc_slice_refcount {
   void Ref(grpc_core::DebugLocation location) {
     auto prev_refs = ref_.fetch_add(1, std::memory_order_relaxed);
     if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
-      gpr_log(location.file(), location.line(), GPR_LOG_SEVERITY_INFO,
-              "REF %p %" PRIdPTR "->%" PRIdPTR, this, prev_refs, prev_refs + 1);
+      LOG(INFO).AtLocation(location.file(), location.line())
+          << "REF " << this << " " << prev_refs << "->" << prev_refs + 1;
     }
   }
   void Unref(grpc_core::DebugLocation location) {
     auto prev_refs = ref_.fetch_sub(1, std::memory_order_acq_rel);
     if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
-      gpr_log(location.file(), location.line(), GPR_LOG_SEVERITY_INFO,
-              "UNREF %p %" PRIdPTR "->%" PRIdPTR, this, prev_refs,
-              prev_refs - 1);
+      LOG(INFO).AtLocation(location.file(), location.line())
+          << "UNREF " << this << " " << prev_refs << "->" << prev_refs - 1;
     }
     if (prev_refs == 1) {
       destroyer_fn_(this);

data/src/core/lib/surface/call.cc

@@ -54,7 +54,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
@@ -63,6 +62,7 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
@@ -92,7 +92,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call_test_only.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -118,12 +117,13 @@ using GrpcClosure = Closure;
 ///////////////////////////////////////////////////////////////////////////////
 // Call
 
-Call::Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena,
-           grpc_event_engine::experimental::EventEngine* event_engine)
+Call::Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena)
     : arena_(std::move(arena)),
       send_deadline_(send_deadline),
-      is_client_(is_client),
-      event_engine_(event_engine) {
+      is_client_(is_client) {
+  DCHECK_NE(arena_.get(), nullptr);
+  DCHECK_NE(arena_->GetContext<grpc_event_engine::experimental::EventEngine>(),
+            nullptr);
   arena_->SetContext<Call>(this);
 }
 
@@ -317,11 +317,9 @@ void Call::HandleCompressionAlgorithmNotAccepted(
     grpc_compression_algorithm compression_algorithm) {
   const char* algo_name = nullptr;
   grpc_compression_algorithm_name(compression_algorithm, &algo_name);
-  gpr_log(GPR_ERROR,
-          "Compression algorithm ('%s') not present in the "
-          "accepted encodings (%s)",
-          algo_name,
-          std::string(encodings_accepted_by_peer_.ToString()).c_str());
+  LOG(ERROR) << "Compression algorithm ('" << algo_name
+             << "') not present in the accepted encodings ("
+             << encodings_accepted_by_peer_.ToString() << ")";
 }
 
 void Call::HandleCompressionAlgorithmDisabled(
@@ -339,8 +337,9 @@ void Call::HandleCompressionAlgorithmDisabled(
 void Call::UpdateDeadline(Timestamp deadline) {
   ReleasableMutexLock lock(&deadline_mu_);
   if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    gpr_log(GPR_DEBUG, "[call %p] UpdateDeadline from=%s to=%s", this,
-            deadline_.ToString().c_str(), deadline.ToString().c_str());
+    VLOG(2) << "[call " << this
+            << "] UpdateDeadline from=" << deadline_.ToString()
+            << " to=" << deadline.ToString();
   }
   if (deadline >= deadline_) return;
   if (deadline < Timestamp::Now()) {
@@ -350,20 +349,25 @@ void Call::UpdateDeadline(Timestamp deadline) {
         StatusIntProperty::kRpcStatus, GRPC_STATUS_DEADLINE_EXCEEDED));
     return;
   }
+  auto* event_engine =
+      arena_->GetContext<grpc_event_engine::experimental::EventEngine>();
   if (deadline_ != Timestamp::InfFuture()) {
-    if (!event_engine_->Cancel(deadline_task_)) return;
+    if (!event_engine->Cancel(deadline_task_)) return;
   } else {
     InternalRef("deadline");
   }
   deadline_ = deadline;
-  deadline_task_ = event_engine_->RunAfter(deadline - Timestamp::Now(), this);
+  deadline_task_ = event_engine->RunAfter(deadline - Timestamp::Now(), this);
 }
 
 void Call::ResetDeadline() {
   {
     MutexLock lock(&deadline_mu_);
     if (deadline_ == Timestamp::InfFuture()) return;
-    if (!event_engine_->Cancel(deadline_task_)) return;
+    if (!arena_->GetContext<grpc_event_engine::experimental::EventEngine>()
+             ->Cancel(deadline_task_)) {
+      return;
+    }
     deadline_ = Timestamp::InfFuture();
   }
   InternalUnref("deadline[reset]");
@@ -408,7 +412,8 @@ char* grpc_call_get_peer(grpc_call* call) {
 }
 
 grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
-  GRPC_API_TRACE("grpc_call_cancel(call=%p, reserved=%p)", 2, (call, reserved));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_cancel(call=" << call << ", reserved=" << reserved << ")";
   CHECK_EQ(reserved, nullptr);
   if (call == nullptr) {
     return GRPC_CALL_ERROR;
@@ -423,10 +428,9 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
                                              grpc_status_code status,
                                              const char* description,
                                              void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_call_cancel_with_status("
-      "c=%p, status=%d, description=%s, reserved=%p)",
-      4, (c, (int)status, description, reserved));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_cancel_with_status(c=" << c << ", status=" << (int)status
+      << ", description=" << description << ", reserved=" << reserved << ")";
   CHECK_EQ(reserved, nullptr);
   if (c == nullptr) {
     return GRPC_CALL_ERROR;
@@ -466,10 +470,10 @@ grpc_call_stack* grpc_call_get_call_stack(grpc_call* call) {
 
 grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
                                       size_t nops, void* tag, void* reserved) {
-  GRPC_API_TRACE(
-      "grpc_call_start_batch(call=%p, ops=%p, nops=%lu, tag=%p, "
-      "reserved=%p)",
-      5, (call, ops, (unsigned long)nops, tag, reserved));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_start_batch(call=" << call << ", ops=" << ops
+      << ", nops=" << (unsigned long)nops << ", tag=" << tag
+      << ", reserved=" << reserved << ")";
 
   if (reserved != nullptr || call == nullptr) {
     return GRPC_CALL_ERROR;
@@ -493,6 +497,13 @@ void grpc_call_tracer_set(grpc_call* call,
   return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
 }
 
+void grpc_call_tracer_set_and_manage(grpc_call* call,
+                                     grpc_core::ClientCallTracer* tracer) {
+  grpc_core::Arena* arena = grpc_call_get_arena(call);
+  arena->ManagedNew<ClientCallTracerWrapper>(tracer);
+  return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
+}
+
 void* grpc_call_tracer_get(grpc_call* call) {
   grpc_core::Arena* arena = grpc_call_get_arena(call);
   auto* call_tracer =
@@ -563,5 +574,8 @@ const char* grpc_call_error_to_string(grpc_call_error error) {
 
 void grpc_call_run_in_event_engine(const grpc_call* call,
                                    absl::AnyInvocable<void()> cb) {
-  grpc_core::Call::FromC(call)->event_engine()->Run(std::move(cb));
+  grpc_core::Call::FromC(call)
+      ->arena()
+      ->GetContext<grpc_event_engine::experimental::EventEngine>()
+      ->Run(std::move(cb));
 }

data/src/core/lib/surface/call.h

@@ -31,7 +31,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_fwd.h"
@@ -46,7 +45,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
@@ -86,7 +84,7 @@ class Call : public CppImplOf<Call, grpc_call>,
              public grpc_event_engine::experimental::EventEngine::
                  Closure /* for deadlines */ {
  public:
-  Arena* arena() { return arena_.get(); }
+  Arena* arena() const { return arena_.get(); }
   bool is_client() const { return is_client_; }
 
   virtual bool Completed() = 0;
@@ -121,11 +119,6 @@ class Call : public CppImplOf<Call, grpc_call>,
   // for that functionality be invented)
   virtual grpc_call_stack* call_stack() = 0;
 
-  // Return the EventEngine used for this call's async execution.
-  grpc_event_engine::experimental::EventEngine* event_engine() const {
-    return event_engine_;
-  }
-
   // Implementation of EventEngine::Closure, called when deadline expires
   void Run() final;
 
@@ -163,8 +156,7 @@ class Call : public CppImplOf<Call, grpc_call>,
     Call* sibling_prev = nullptr;
   };
 
-  Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena,
-       grpc_event_engine::experimental::EventEngine* event_engine);
+  Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena);
   ~Call() override = default;
 
   ParentCall* GetOrCreateParentCall();
@@ -234,7 +226,6 @@ class Call : public CppImplOf<Call, grpc_call>,
   Timestamp deadline_ ABSL_GUARDED_BY(deadline_mu_) = Timestamp::InfFuture();
   grpc_event_engine::experimental::EventEngine::TaskHandle ABSL_GUARDED_BY(
       deadline_mu_) deadline_task_;
-  grpc_event_engine::experimental::EventEngine* const event_engine_;
   gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
 };
 
@@ -269,22 +260,41 @@ void grpc_call_cancel_internal(grpc_call* call);
 // Given the top call_element, get the call object.
 grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 
-void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
-                         const grpc_op* ops, size_t nops);
+void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
+                         size_t nops);
 
 void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
 
+// Sets call tracer on the call and manages its life by using the call's arena.
+// When using this API, the tracer will be destroyed by grpc_call arena when
+// grpc_call is about to be destroyed. The caller of this API SHOULD NOT
+// manually destroy the tracer. This API is used by Python as a way of using
+// Arena to manage the lifetime of the call tracer. Python needs this API
+// because the tracer was created within a separate shared object library which
+// doesn't have access to core functions like arena->ManagedNew<>.
+void grpc_call_tracer_set_and_manage(grpc_call* call,
+                                     grpc_core::ClientCallTracer* tracer);
+
 void* grpc_call_tracer_get(grpc_call* call);
 
-#define GRPC_CALL_LOG_BATCH(sev, ops, nops) \
-  do {                                      \
-    if (GRPC_TRACE_FLAG_ENABLED(api)) {     \
-      grpc_call_log_batch(sev, ops, nops);  \
-    }                                       \
+#define GRPC_CALL_LOG_BATCH(ops, nops)                    \
+  do {                                                    \
+    if (GRPC_TRACE_FLAG_ENABLED(api)) {                   \
+      grpc_call_log_batch(__FILE__, __LINE__, ops, nops); \
+    }                                                     \
   } while (0)
 
 uint8_t grpc_call_is_client(grpc_call* call);
 
+class ClientCallTracerWrapper {
+ public:
+  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracer* tracer)
+      : tracer_(tracer) {}
+
+ private:
+  std::unique_ptr<grpc_core::ClientCallTracer> tracer_;
+};
+
 // Return an appropriate compression algorithm for the requested compression \a
 // level in the context of \a call.
 grpc_compression_algorithm grpc_call_compression_for_level(

data/src/core/lib/surface/call_details.cc

@@ -23,16 +23,17 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/api_trace.h"
 
 void grpc_call_details_init(grpc_call_details* details) {
-  GRPC_API_TRACE("grpc_call_details_init(details=%p)", 1, (details));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_details_init(details=" << details << ")";
   details->method = grpc_empty_slice();
   details->host = grpc_empty_slice();
 }
 
 void grpc_call_details_destroy(grpc_call_details* details) {
-  GRPC_API_TRACE("grpc_call_details_destroy(details=%p)", 1, (details));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_call_details_destroy(details=" << details << ")";
   grpc_core::ExecCtx exec_ctx;
   grpc_core::CSliceUnref(details->method);
   grpc_core::CSliceUnref(details->host);

data/src/core/lib/surface/call_log_batch.cc

@@ -28,7 +28,6 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice_internal.h"
@@ -106,10 +105,10 @@ static std::string grpc_op_string(const grpc_op* op) {
   return absl::StrJoin(parts, "");
 }
 
-void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
-                         const grpc_op* ops, size_t nops) {
+void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
+                         size_t nops) {
   for (size_t i = 0; i < nops; i++) {
-    gpr_log(file, line, severity, "ops[%" PRIuPTR "]: %s", i,
-            grpc_op_string(&ops[i]).c_str());
+    LOG(INFO).AtLocation(file, line)
+        << "ops[" << i << "]: " << grpc_op_string(&ops[i]);
   }
 }

data/src/core/lib/surface/call_utils.cc

@@ -28,6 +28,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"
@@ -44,7 +45,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
@@ -88,11 +88,9 @@ void CToMetadata(grpc_metadata* metadata, size_t count,
     if (key == "content-length") continue;
     b->Append(key, Slice(CSliceRef(md->value)),
               [md](absl::string_view error, const Slice& value) {
-                gpr_log(GPR_DEBUG, "Append error: %s",
-                        absl::StrCat("key=", StringViewFromSlice(md->key),
-                                     " error=", error,
-                                     " value=", value.as_string_view())
-                            .c_str());
+                VLOG(2) << "Append error: key=" << StringViewFromSlice(md->key)
+                        << " error=" << error
+                        << " value=" << value.as_string_view();
               });
   }
 }
@@ -219,7 +217,7 @@ std::string MakeErrorString(const ServerMetadata* trailing_metadata) {
       trailing_metadata->get(GrpcStatusFromWire()).value_or(false)
           ? "Error received from peer"
           : "Error generated by client",
-      "grpc_status: ",
+      " grpc_status: ",
       grpc_status_code_to_string(trailing_metadata->get(GrpcStatusMetadata())
                                      .value_or(GRPC_STATUS_UNKNOWN)));
   if (const Slice* message =