grpc 1.65.2 → 1.66.0.pre3

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

@@ -36,7 +36,6 @@
 #include <grpc/grpc.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/sync.h>
 #include <grpc/support/time.h>
@@ -51,7 +50,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/event_string.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
@@ -438,14 +436,14 @@ static const cq_vtable g_cq_vtable[] = {
 #define POLLSET_FROM_CQ(cq) \
   ((grpc_pollset*)((cq)->vtable->data_size + (char*)DATA_FROM_CQ(cq)))
 
-#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event) \
-  do {                                               \
-    if (GRPC_TRACE_FLAG_ENABLED(api) &&              \
-        (GRPC_TRACE_FLAG_ENABLED(queue_pluck) ||     \
-         (event)->type != GRPC_QUEUE_TIMEOUT)) {     \
-      gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq,  \
-              grpc_event_string(event).c_str());     \
-    }                                                \
+#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)  \
+  do {                                                \
+    if (GRPC_TRACE_FLAG_ENABLED(api) &&               \
+        (GRPC_TRACE_FLAG_ENABLED(queue_pluck) ||      \
+         (event)->type != GRPC_QUEUE_TIMEOUT)) {      \
+      LOG(INFO) << "RETURN_EVENT[" << (cq)            \
+                << "]: " << grpc_event_string(event); \
+    }                                                 \
   } while (0)
 
 static void on_pollset_shutdown_done(void* arg, grpc_error_handle error);
@@ -509,10 +507,9 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_completion_queue_functor* shutdown_callback) {
   grpc_completion_queue* cq;
 
-  GRPC_API_TRACE(
-      "grpc_completion_queue_create_internal(completion_type=%d, "
-      "polling_type=%d)",
-      2, (completion_type, polling_type));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_completion_queue_create_internal(completion_type="
+      << completion_type << ", polling_type=" << polling_type << ")";
 
   switch (completion_type) {
     case GRPC_CQ_NEXT:
@@ -698,13 +695,12 @@ static void cq_end_op_for_next(
   if (GRPC_TRACE_FLAG_ENABLED(api) ||
       (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok())) {
     std::string errmsg = grpc_core::StatusToString(error);
-    GRPC_API_TRACE(
-        "cq_end_op_for_next(cq=%p, tag=%p, error=%s, "
-        "done=%p, done_arg=%p, storage=%p)",
-        6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
+    GRPC_TRACE_LOG(api, INFO)
+        << "cq_end_op_for_next(cq=" << cq << ", tag=" << tag
+        << ", error=" << errmsg.c_str() << ", done=" << done
+        << ", done_arg=" << done_arg << ", storage=" << storage << ")";
     if (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok()) {
-      gpr_log(GPR_INFO, "Operation failed: tag=%p, error=%s", tag,
-              errmsg.c_str());
+      LOG(INFO) << "Operation failed: tag=" << tag << ", error=" << errmsg;
     }
   }
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
@@ -737,8 +733,8 @@ static void cq_end_op_for_next(
         gpr_mu_unlock(cq->mu);
 
         if (!kick_error.ok()) {
-          gpr_log(GPR_ERROR, "Kick failed: %s",
-                  grpc_core::StatusToString(kick_error).c_str());
+          LOG(ERROR) << "Kick failed: "
+                     << grpc_core::StatusToString(kick_error);
         }
       }
       if (cqd->pending_events.fetch_sub(1, std::memory_order_acq_rel) == 1) {
@@ -772,13 +768,12 @@ static void cq_end_op_for_pluck(
   if (GRPC_TRACE_FLAG_ENABLED(api) ||
       (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok())) {
     std::string errmsg = grpc_core::StatusToString(error);
-    GRPC_API_TRACE(
-        "cq_end_op_for_pluck(cq=%p, tag=%p, error=%s, "
-        "done=%p, done_arg=%p, storage=%p)",
-        6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
+    GRPC_TRACE_LOG(api, INFO)
+        << "cq_end_op_for_pluck(cq=" << cq << ", tag=" << tag
+        << ", error=" << errmsg.c_str() << ", done=" << done
+        << ", done_arg=" << done_arg << ", storage=" << storage << ")";
     if (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok()) {
-      gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag,
-              errmsg.c_str());
+      LOG(ERROR) << "Operation failed: tag=" << tag << ", error=" << errmsg;
     }
   }
 
@@ -813,8 +808,7 @@ static void cq_end_op_for_pluck(
         cq->poller_vtable->kick(POLLSET_FROM_CQ(cq), pluck_worker);
     gpr_mu_unlock(cq->mu);
     if (!kick_error.ok()) {
-      gpr_log(GPR_ERROR, "Kick failed: %s",
-              grpc_core::StatusToString(kick_error).c_str());
+      LOG(ERROR) << "Kick failed: " << kick_error;
     }
   }
 }
@@ -834,13 +828,12 @@ static void cq_end_op_for_callback(
   if (GRPC_TRACE_FLAG_ENABLED(api) ||
       (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok())) {
     std::string errmsg = grpc_core::StatusToString(error);
-    GRPC_API_TRACE(
-        "cq_end_op_for_callback(cq=%p, tag=%p, error=%s, "
-        "done=%p, done_arg=%p, storage=%p)",
-        6, (cq, tag, errmsg.c_str(), done, done_arg, storage));
+    GRPC_TRACE_LOG(api, INFO)
+        << "cq_end_op_for_callback(cq=" << cq << ", tag=" << tag
+        << ", error=" << errmsg.c_str() << ", done=" << done
+        << ", done_arg=" << done_arg << ", storage=" << storage << ")";
     if (GRPC_TRACE_FLAG_ENABLED(op_failure) && !error.ok()) {
-      gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag,
-              errmsg.c_str());
+      LOG(ERROR) << "Operation failed: tag=" << tag << ", error=" << errmsg;
     }
   }
 
@@ -948,15 +941,12 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
   grpc_event ret;
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
-  GRPC_API_TRACE(
-      "grpc_completion_queue_next("
-      "cq=%p, "
-      "deadline=gpr_timespec { tv_sec: %" PRId64
-      ", tv_nsec: %d, clock_type: %d }, "
-      "reserved=%p)",
-      5,
-      (cq, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type,
-       reserved));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_completion_queue_next(cq=" << cq
+      << ", deadline=gpr_timespec { tv_sec: " << deadline.tv_sec
+      << ", tv_nsec: " << deadline.tv_nsec
+      << ", clock_type: " << (int)deadline.clock_type
+      << " }, reserved=" << reserved << ")";
   CHECK(!reserved);
 
   dump_pending_tags(cq);
@@ -1039,8 +1029,8 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
     gpr_mu_unlock(cq->mu);
 
     if (!err.ok()) {
-      gpr_log(GPR_ERROR, "Completion queue next failed: %s",
-              grpc_core::StatusToString(err).c_str());
+      LOG(ERROR) << "Completion queue next failed: "
+                 << grpc_core::StatusToString(err);
       if (err == absl::CancelledError()) {
         ret.type = GRPC_QUEUE_SHUTDOWN;
       } else {
@@ -1192,15 +1182,12 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
   cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
   if (GRPC_TRACE_FLAG_ENABLED(queue_pluck)) {
-    GRPC_API_TRACE(
-        "grpc_completion_queue_pluck("
-        "cq=%p, tag=%p, "
-        "deadline=gpr_timespec { tv_sec: %" PRId64
-        ", tv_nsec: %d, clock_type: %d }, "
-        "reserved=%p)",
-        6,
-        (cq, tag, deadline.tv_sec, deadline.tv_nsec, (int)deadline.clock_type,
-         reserved));
+    GRPC_TRACE_LOG(api, INFO)
+        << "grpc_completion_queue_pluck(cq=" << cq << ", tag=" << tag
+        << ", deadline=gpr_timespec { tv_sec: " << deadline.tv_sec
+        << ", tv_nsec: " << deadline.tv_nsec
+        << ", clock_type: " << (int)deadline.clock_type
+        << " }, reserved=" << reserved << ")";
   }
   CHECK(!reserved);
 
@@ -1253,10 +1240,9 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
       break;
     }
     if (!add_plucker(cq, tag, &worker)) {
-      gpr_log(GPR_DEBUG,
-              "Too many outstanding grpc_completion_queue_pluck calls: maximum "
-              "is %d",
-              GRPC_MAX_COMPLETION_QUEUE_PLUCKERS);
+      VLOG(2) << "Too many outstanding grpc_completion_queue_pluck calls: "
+                 "maximum is "
+              << GRPC_MAX_COMPLETION_QUEUE_PLUCKERS;
       gpr_mu_unlock(cq->mu);
       // TODO(ctiller): should we use a different result here
       ret.type = GRPC_QUEUE_TIMEOUT;
@@ -1279,8 +1265,8 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
     if (!err.ok()) {
       del_plucker(cq, tag, &worker);
       gpr_mu_unlock(cq->mu);
-      gpr_log(GPR_ERROR, "Completion queue pluck failed: %s",
-              grpc_core::StatusToString(err).c_str());
+      LOG(ERROR) << "Completion queue pluck failed: "
+                 << grpc_core::StatusToString(err);
       ret.type = GRPC_QUEUE_TIMEOUT;
       ret.success = 0;
       dump_pending_tags(cq);
@@ -1389,12 +1375,13 @@ static void cq_shutdown_callback(grpc_completion_queue* cq) {
 void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE("grpc_completion_queue_shutdown(cq=%p)", 1, (cq));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_completion_queue_shutdown(cq=" << cq << ")";
   cq->vtable->shutdown(cq);
 }
 
 void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
-  GRPC_API_TRACE("grpc_completion_queue_destroy(cq=%p)", 1, (cq));
+  GRPC_TRACE_LOG(api, INFO) << "grpc_completion_queue_destroy(cq=" << cq << ")";
   grpc_completion_queue_shutdown(cq);
 
   grpc_core::ExecCtx exec_ctx;

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

@@ -41,12 +41,12 @@
 #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>
 
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -59,7 +59,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_utils.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -83,7 +82,7 @@ using GrpcClosure = Closure;
 FilterStackCall::FilterStackCall(RefCountedPtr<Arena> arena,
                                  const grpc_call_create_args& args)
     : Call(args.server_transport_data == nullptr, args.send_deadline,
-           std::move(arena), args.channel->event_engine()),
+           std::move(arena)),
       channel_(args.channel->RefAsSubclass<Channel>()),
       cq_(args.cq),
       stream_op_payload_{} {}
@@ -109,6 +108,8 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
       channel_stack->call_stack_size;
 
   RefCountedPtr<Arena> arena = channel->call_arena_allocator()->MakeArena();
+  arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+      args->channel->event_engine());
   call = new (arena->Alloc(call_alloc_size)) FilterStackCall(arena, *args);
   DCHECK(FromC(call->c_ptr()) == call);
   DCHECK(FromCallStack(call->call_stack()) == call);
@@ -267,7 +268,7 @@ void FilterStackCall::ExternalUnref() {
   ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
 
-  GRPC_API_TRACE("grpc_call_unref(c=%p)", 1, (this));
+  GRPC_TRACE_LOG(api, INFO) << "grpc_call_unref(c=" << this << ")";
 
   MaybeUnpublishFromParent();
 
@@ -298,7 +299,9 @@ void FilterStackCall::ExecuteBatch(grpc_transport_stream_op_batch* batch,
     auto* call =
         static_cast<FilterStackCall*>(batch->handler_private.extra_arg);
     grpc_call_element* elem = call->call_elem(0);
-    GRPC_CALL_LOG_OP(GPR_INFO, elem, batch);
+    GRPC_TRACE_LOG(channel, INFO)
+        << "OP[" << elem->filter->name << ":" << elem
+        << "]: " << grpc_transport_stream_op_batch_string(batch, false);
     elem->filter->start_transport_stream_op_batch(elem, batch);
   };
   batch->handler_private.extra_arg = this;
@@ -412,11 +415,10 @@ bool FilterStackCall::PrepareApplicationMetadata(size_t count,
     }
     batch->Append(StringViewFromSlice(md->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();
                   });
   }
 
@@ -747,13 +749,12 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
   if (!is_client() &&
       (seen_ops & (1u << GRPC_OP_SEND_STATUS_FROM_SERVER)) != 0 &&
       (seen_ops & (1u << GRPC_OP_RECV_MESSAGE)) != 0) {
-    gpr_log(GPR_ERROR,
-            "******************* SEND_STATUS WITH RECV_MESSAGE "
-            "*******************");
+    LOG(ERROR) << "******************* SEND_STATUS WITH RECV_MESSAGE "
+                  "*******************";
     return GRPC_CALL_ERROR;
   }
 
-  GRPC_CALL_LOG_BATCH(GPR_INFO, ops, nops);
+  GRPC_CALL_LOG_BATCH(ops, nops);
 
   if (nops == 0) {
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);

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

@@ -34,6 +34,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/experiments/config.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
@@ -44,13 +45,16 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/security/transport/auth_filters.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
 
 // Remnants of the old plugin system
 void grpc_resolver_dns_ares_init(void);
 void grpc_resolver_dns_ares_shutdown(void);
+void grpc_resolver_dns_ares_reset_dns_resolver(void);
+
+extern absl::Status AresInit();
+extern void AresShutdown();
 
 #define MAX_PLUGINS 128
 
@@ -109,11 +113,21 @@ void grpc_init(void) {
       g_shutting_down_cv->SignalAll();
     }
     grpc_iomgr_init();
-    grpc_resolver_dns_ares_init();
+    if (grpc_core::IsEventEngineDnsEnabled()) {
+      auto status = AresInit();
+      if (!status.ok()) {
+        VLOG(2) << "AresInit failed: " << status.message();
+      } else {
+        // TODO(yijiem): remove this once we remove the iomgr dns system.
+        grpc_resolver_dns_ares_reset_dns_resolver();
+      }
+    } else {
+      grpc_resolver_dns_ares_init();
+    }
     grpc_iomgr_start();
   }
 
-  GRPC_API_TRACE("grpc_init(void)", 0, ());
+  GRPC_TRACE_LOG(api, INFO) << "grpc_init(void)";
 }
 
 void grpc_shutdown_internal_locked(void)
@@ -122,7 +136,11 @@ void grpc_shutdown_internal_locked(void)
     grpc_core::ExecCtx exec_ctx(0);
     grpc_iomgr_shutdown_background_closure();
     grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread
-    grpc_resolver_dns_ares_shutdown();
+    if (grpc_core::IsEventEngineDnsEnabled()) {
+      AresShutdown();
+    } else {
+      grpc_resolver_dns_ares_shutdown();
+    }
     grpc_iomgr_shutdown();
   }
   g_shutting_down = false;
@@ -130,7 +148,7 @@ void grpc_shutdown_internal_locked(void)
 }
 
 void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
-  GRPC_API_TRACE("grpc_shutdown_from_cleanup_thread", 0, ());
+  GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_from_cleanup_thread";
   grpc_core::MutexLock lock(g_init_mu);
   // We have released lock from the shutdown thread and it is possible that
   // another grpc_init has been called, and do nothing if that is the case.
@@ -142,7 +160,7 @@ void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
 }
 
 void grpc_shutdown(void) {
-  GRPC_API_TRACE("grpc_shutdown(void)", 0, ());
+  GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown(void)";
   grpc_core::MutexLock lock(g_init_mu);
 
   if (--g_initializations == 0) {
@@ -175,7 +193,7 @@ void grpc_shutdown(void) {
 }
 
 void grpc_shutdown_blocking(void) {
-  GRPC_API_TRACE("grpc_shutdown_blocking(void)", 0, ());
+  GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_blocking(void)";
   grpc_core::MutexLock lock(g_init_mu);
   if (--g_initializations == 0) {
     g_shutting_down = true;

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

@@ -42,7 +42,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/promise.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -57,7 +56,7 @@ namespace grpc_core {
 
 const grpc_channel_filter LameClientFilter::kFilter =
     MakePromiseBasedFilter<LameClientFilter, FilterEndpoint::kClient,
-                           kFilterIsLast>("lame-client");
+                           kFilterIsLast>();
 
 absl::StatusOr<std::unique_ptr<LameClientFilter>> LameClientFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {

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

@@ -47,6 +47,8 @@ class LameClientFilter : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "lame-client"; }
+
   explicit LameClientFilter(absl::Status error);
 
   static absl::StatusOr<std::unique_ptr<LameClientFilter>> Create(

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

@@ -20,6 +20,7 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
@@ -27,7 +28,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channelz.h"
@@ -37,6 +37,7 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -85,8 +86,7 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
   if (!r.ok()) {
     auto status = r.status();
-    gpr_log(GPR_ERROR, "channel stack builder failed: %s",
-            status.ToString().c_str());
+    LOG(ERROR) << "channel stack builder failed: " << status;
     return status;
   }
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
@@ -107,7 +107,10 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
                                 .value_or(CoreConfiguration::Get()
                                               .resolver_registry()
                                               .GetDefaultAuthority(target));
-    experimental::StatsPluginChannelScope scope(target, authority);
+    grpc_event_engine::experimental::ChannelArgsEndpointConfig endpoint_config(
+        args);
+    experimental::StatsPluginChannelScope scope(target, authority,
+                                                endpoint_config);
     *(*r)->stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
     // Add per-channel stats plugins.
@@ -206,9 +209,8 @@ grpc_connectivity_state LegacyChannel::CheckConnectivityState(
   ClientChannelFilter* client_channel = GetClientChannelFilter();
   if (GPR_UNLIKELY(client_channel == nullptr)) {
     if (IsLame()) return GRPC_CHANNEL_TRANSIENT_FAILURE;
-    gpr_log(GPR_ERROR,
-            "grpc_channel_check_connectivity_state called on something that is "
-            "not a client channel");
+    LOG(ERROR) << "grpc_channel_check_connectivity_state called on something "
+                  "that is not a client channel";
     return GRPC_CHANNEL_SHUTDOWN;
   }
   return client_channel->CheckConnectivityState(try_to_connect);

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

@@ -23,14 +23,15 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/surface/api_trace.h"
 
 void grpc_metadata_array_init(grpc_metadata_array* array) {
-  GRPC_API_TRACE("grpc_metadata_array_init(array=%p)", 1, (array));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_metadata_array_init(array=" << array << ")";
   memset(array, 0, sizeof(*array));
 }
 
 void grpc_metadata_array_destroy(grpc_metadata_array* array) {
-  GRPC_API_TRACE("grpc_metadata_array_destroy(array=%p)", 1, (array));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_metadata_array_destroy(array=" << array << ")";
   gpr_free(array->metadata);
 }

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

@@ -188,6 +188,8 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
         [this, cancelled = op->data.recv_close_on_server.cancelled]() {
           return Map(call_handler_.WasCancelled(),
                      [cancelled, this](bool result) -> Success {
+                       saw_was_cancelled_.store(true,
+                                                std::memory_order_relaxed);
                        ResetDeadline();
                        *cancelled = result ? 1 : 0;
                        return Success{};

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

@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <atomic>
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -68,7 +69,7 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
       : Call(false,
              client_initial_metadata->get(GrpcTimeoutMetadata())
                  .value_or(Timestamp::InfFuture()),
-             call_handler.arena()->Ref(), call_handler.event_engine()),
+             call_handler.arena()->Ref()),
         call_handler_(std::move(call_handler)),
         client_initial_metadata_stored_(std::move(client_initial_metadata)),
         cq_(cq),
@@ -80,9 +81,8 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
     call_handler_.SpawnInfallible(
         "CancelWithError",
         [self = WeakRefAsSubclass<ServerCall>(), error = std::move(error)] {
-          auto status = ServerMetadataFromStatus(error);
-          status->Set(GrpcCallWasCancelled(), true);
-          self->call_handler_.PushServerTrailingMetadata(std::move(status));
+          self->call_handler_.PushServerTrailingMetadata(
+              CancelledServerMetadataFromStatus(error));
           return Empty{};
         });
   }
@@ -101,8 +101,9 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   void InternalUnref(const char*) override { WeakUnref(); }
 
   void Orphaned() override {
-    // TODO(ctiller): only when we're not already finished
-    CancelWithError(absl::CancelledError());
+    if (!saw_was_cancelled_.load(std::memory_order_relaxed)) {
+      CancelWithError(absl::CancelledError());
+    }
   }
 
   void SetCompletionQueue(grpc_completion_queue*) override {
@@ -155,6 +156,7 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   ClientMetadataHandle client_initial_metadata_stored_;
   grpc_completion_queue* const cq_;
   ServerInterface* const server_;
+  std::atomic<bool> saw_was_cancelled_{false};
 };
 
 grpc_call* MakeServerCall(CallHandler call_handler,

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "42.0.0"; }
+const char* grpc_version_string(void) { return "43.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gnarly"; }
+const char* grpc_g_stands_for(void) { return "gladiator"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -24,6 +24,7 @@
 #include <algorithm>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/port_platform.h>
 
@@ -47,19 +48,16 @@ Timestamp BdpEstimator::CompletePing() {
   double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
   Duration start_inter_ping_delay = inter_ping_delay_;
   if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-    gpr_log(GPR_INFO,
-            "bdp[%s]:complete acc=%" PRId64 " est=%" PRId64
-            " dt=%lf bw=%lfMbs bw_est=%lfMbs",
-            std::string(name_).c_str(), accumulator_, estimate_, dt,
-            bw / 125000.0, bw_est_ / 125000.0);
+    LOG(INFO) << "bdp[" << name_ << "]:complete acc=" << accumulator_
+              << " est=" << estimate_ << " dt=" << dt << " bw=" << bw / 125000.0
+              << "Mbs bw_est=" << bw_est_ / 125000.0 << "Mbs";
   }
   CHECK(ping_state_ == PingState::STARTED);
   if (accumulator_ > 2 * estimate_ / 3 && bw > bw_est_) {
     estimate_ = std::max(accumulator_, estimate_ * 2);
     bw_est_ = bw;
     if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      gpr_log(GPR_INFO, "bdp[%s]: estimate increased to %" PRId64,
-              std::string(name_).c_str(), estimate_);
+      LOG(INFO) << "bdp[" << name_ << "]: estimate increased to " << estimate_;
     }
     inter_ping_delay_ /= 2;  // if the ping estimate changes,
                              // exponentially get faster at probing
@@ -74,8 +72,8 @@ Timestamp BdpEstimator::CompletePing() {
   if (start_inter_ping_delay != inter_ping_delay_) {
     stable_estimate_count_ = 0;
     if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      gpr_log(GPR_INFO, "bdp[%s]:update_inter_time to %" PRId64 "ms",
-              std::string(name_).c_str(), inter_ping_delay_.millis());
+      LOG(INFO) << "bdp[" << name_ << "]:update_inter_time to "
+                << inter_ping_delay_.millis() << "ms";
     }
   }
   ping_state_ = PingState::UNSCHEDULED;