grpc 1.75.0 → 1.78.1

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

@@ -28,16 +28,18 @@
 #include <utility>
 #include <vector>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "src/core/call/call_filters.h"
 #include "src/core/call/interception_chain.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/functional/any_invocable.h"
 
 /// This module provides a way for plugins (and the grpc core library itself)
 /// to register mutators for channel stacks.
@@ -246,26 +248,36 @@ class ChannelInit {
     // stack.
     FilterRegistration& ExcludeFromMinimalStack();
     FilterRegistration& SkipV3() {
-      CHECK_EQ(version_, Version::kAny);
+      GRPC_CHECK_EQ(version_, Version::kAny);
       version_ = Version::kV2;
       return *this;
     }
     FilterRegistration& SkipV2() {
-      CHECK_EQ(version_, Version::kAny);
+      GRPC_CHECK_EQ(version_, Version::kAny);
       version_ = Version::kV3;
       return *this;
     }
     // Request this filter be placed as high as possible in the stack (given
     // before/after constraints).
     FilterRegistration& FloatToTop() {
-      CHECK_EQ(ordering_, Ordering::kDefault);
+      GRPC_CHECK_EQ(ordering_, Ordering::kDefault);
+      ordering_ = Ordering::kTop;
+      return *this;
+    }
+    // Request this filter be placed as high as possible in the stack (given
+    // before/after constraints).
+    FilterRegistration& FloatToTopIf(bool predicate) {
+      if (!predicate) {
+        return *this;
+      }
+      GRPC_CHECK_EQ(ordering_, Ordering::kDefault);
       ordering_ = Ordering::kTop;
       return *this;
     }
     // Request this filter be placed as low as possible in the stack (given
     // before/after constraints).
     FilterRegistration& SinkToBottom() {
-      CHECK_EQ(ordering_, Ordering::kDefault);
+      GRPC_CHECK_EQ(ordering_, Ordering::kDefault);
       ordering_ = Ordering::kBottom;
       return *this;
     }
@@ -303,7 +315,7 @@ class ChannelInit {
     FilterRegistration& RegisterFilter(
         grpc_channel_stack_type type, const grpc_channel_filter* filter,
         SourceLocation registration_source = {}) {
-      CHECK(filter != nullptr);
+      GRPC_CHECK(filter != nullptr);
       return RegisterFilter(type, NameFromChannelFilter(filter), filter,
                             nullptr, registration_source);
     }
@@ -312,7 +324,9 @@ class ChannelInit {
         grpc_channel_stack_type type, SourceLocation registration_source = {}) {
       return RegisterFilter(
           type, UniqueTypeNameFor<Filter>(), &Filter::kFilter,
-          [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
+          [](InterceptionChainBuilder& builder) {
+            builder.Add<Filter>(nullptr);
+          },
           registration_source);
     }
 
@@ -338,7 +352,7 @@ class ChannelInit {
     void RegisterFusedFilter(grpc_channel_stack_type type,
                              const grpc_channel_filter* filter,
                              SourceLocation registration_source = {}) {
-      CHECK(filter != nullptr);
+      GRPC_CHECK(filter != nullptr);
       RegisterFusedFilter(type, NameFromChannelFilter(filter), filter, nullptr,
                           registration_source);
     }
@@ -361,7 +375,7 @@ class ChannelInit {
                                PostProcessorSlot slot,
                                PostProcessor post_processor) {
       auto& slot_value = post_processors_[type][static_cast<int>(slot)];
-      CHECK(slot_value == nullptr);
+      GRPC_CHECK(slot_value == nullptr);
       slot_value = std::move(post_processor);
     }
 
@@ -385,6 +399,8 @@ class ChannelInit {
   void AddToInterceptionChainBuilder(grpc_channel_stack_type type,
                                      InterceptionChainBuilder& builder) const;
 
+  void AddData(channelz::DataSink sink, grpc_channel_stack_type type) const;
+
  private:
   // The type of object returned by a filter's Create method.
   template <typename T>
@@ -425,6 +441,7 @@ class ChannelInit {
     std::vector<Filter> fused_filters;
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
+    channelz::PropertyTable filter_ordering;
   };
 
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
@@ -433,7 +450,7 @@ class ChannelInit {
   SortFilterRegistrationsByDependencies(
       const std::vector<std::unique_ptr<FilterRegistration>>&
           filter_registrations,
-      grpc_channel_stack_type type);
+      grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering);
 
   static std::vector<Filter> SortFusedFilterRegistrations(
       const std::vector<std::unique_ptr<FilterRegistration>>&
@@ -443,8 +460,8 @@ class ChannelInit {
   static std::vector<FilterNode> SelectFiltersByPredicate(
       const std::vector<Filter>& filters, ChannelStackBuilder* builder);
 
-  static void MergeFilters(std::vector<FilterNode>& filter_list,
-                           const std::vector<Filter>& fused_filters);
+  static void MergeFusedFilters(ChannelStackBuilder* builder,
+                                const std::vector<Filter>& fused_filters);
 
   static void AppendFiltersToBuilder(const std::vector<FilterNode>& filter_list,
                                      ChannelStackBuilder* builder);

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

@@ -32,11 +32,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -46,10 +41,15 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/atomic_utils.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/spinlock.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 namespace {
 
@@ -166,7 +166,7 @@ grpc_error_handle non_polling_poller_kick(
 
 void non_polling_poller_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   non_polling_poller* p = reinterpret_cast<non_polling_poller*>(pollset);
-  CHECK_NE(closure, nullptr);
+  GRPC_CHECK_NE(closure, nullptr);
   p->shutdown = closure;
   if (p->root == nullptr) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
@@ -311,7 +311,7 @@ class CqEventQueue {
 
 struct cq_next_data {
   ~cq_next_data() {
-    CHECK_EQ(queue.num_items(), 0);
+    GRPC_CHECK_EQ(queue.num_items(), 0);
 #ifndef NDEBUG
     if (pending_events.load(std::memory_order_acquire) != 0) {
       LOG(ERROR) << "Destroying CQ without draining it fully.";
@@ -341,7 +341,8 @@ struct cq_pluck_data {
   }
 
   ~cq_pluck_data() {
-    CHECK(completed_head.next == reinterpret_cast<uintptr_t>(&completed_head));
+    GRPC_CHECK(completed_head.next ==
+               reinterpret_cast<uintptr_t>(&completed_head));
 #ifndef NDEBUG
     if (pending_events.load(std::memory_order_acquire) != 0) {
       LOG(ERROR) << "Destroying CQ without draining it fully.";
@@ -710,7 +711,7 @@ static void cq_check_tag(grpc_completion_queue* cq, void* tag, bool lock_cq) {
     gpr_mu_unlock(cq->mu);
   }
 
-  CHECK(found);
+  GRPC_CHECK(found);
 }
 #else
 static void cq_check_tag(grpc_completion_queue* /*cq*/, void* /*tag*/,
@@ -940,7 +941,7 @@ class ExecCtxNext : public grpc_core::ExecCtx {
         static_cast<cq_is_finished_arg*>(check_ready_to_finish_arg_);
     grpc_completion_queue* cq = a->cq;
     cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
-    CHECK_EQ(a->stolen_completion, nullptr);
+    GRPC_CHECK_EQ(a->stolen_completion, nullptr);
 
     intptr_t current_last_seen_things_queued_ever =
         cqd->things_queued_ever.load(std::memory_order_relaxed);
@@ -994,7 +995,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
       << ", tv_nsec: " << deadline.tv_nsec
       << ", clock_type: " << (int)deadline.clock_type
       << " }, reserved=" << reserved << ")";
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
 
   dump_pending_tags(cq);
 
@@ -1100,7 +1101,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
   GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, &ret);
   GRPC_CQ_INTERNAL_UNREF(cq, "next");
 
-  CHECK_EQ(is_finished_arg.stolen_completion, nullptr);
+  GRPC_CHECK_EQ(is_finished_arg.stolen_completion, nullptr);
 
   return ret;
 }
@@ -1114,8 +1115,8 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
 static void cq_finish_shutdown_next(grpc_completion_queue* cq) {
   cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
-  CHECK(cqd->shutdown_called);
-  CHECK_EQ(cqd->pending_events.load(std::memory_order_relaxed), 0);
+  GRPC_CHECK(cqd->shutdown_called);
+  GRPC_CHECK_EQ(cqd->pending_events.load(std::memory_order_relaxed), 0);
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
 }
@@ -1188,7 +1189,7 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
     grpc_completion_queue* cq = a->cq;
     cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
-    CHECK_EQ(a->stolen_completion, nullptr);
+    GRPC_CHECK_EQ(a->stolen_completion, nullptr);
     gpr_atm current_last_seen_things_queued_ever =
         cqd->things_queued_ever.load(std::memory_order_relaxed);
     if (current_last_seen_things_queued_ever !=
@@ -1236,7 +1237,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
         << ", clock_type: " << (int)deadline.clock_type
         << " }, reserved=" << reserved << ")";
   }
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
 
   dump_pending_tags(cq);
 
@@ -1326,7 +1327,7 @@ done:
   GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, &ret);
   GRPC_CQ_INTERNAL_UNREF(cq, "pluck");
 
-  CHECK_EQ(is_finished_arg.stolen_completion, nullptr);
+  GRPC_CHECK_EQ(is_finished_arg.stolen_completion, nullptr);
 
   return ret;
 }
@@ -1339,8 +1340,8 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
 static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) {
   cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
-  CHECK(cqd->shutdown_called);
-  CHECK(!cqd->shutdown.load(std::memory_order_relaxed));
+  GRPC_CHECK(cqd->shutdown_called);
+  GRPC_CHECK(!cqd->shutdown.load(std::memory_order_relaxed));
   cqd->shutdown.store(true, std::memory_order_relaxed);
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
@@ -1376,7 +1377,7 @@ static void cq_finish_shutdown_callback(grpc_completion_queue* cq) {
   cq_callback_data* cqd = static_cast<cq_callback_data*> DATA_FROM_CQ(cq);
   auto* callback = cqd->shutdown_callback;
 
-  CHECK(cqd->shutdown_called);
+  GRPC_CHECK(cqd->shutdown_called);
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
 

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

@@ -21,9 +21,9 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/completion_queue.h"
+#include "src/core/util/grpc_check.h"
 
 //
 // == Default completion queue factory implementation ==
@@ -47,8 +47,8 @@ static const grpc_completion_queue_factory g_default_cq_factory = {
 
 const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
     const grpc_completion_queue_attributes* attributes) {
-  CHECK(attributes->version >= 1 &&
-        attributes->version <= GRPC_CQ_CURRENT_VERSION);
+  GRPC_CHECK(attributes->version >= 1 &&
+             attributes->version <= GRPC_CQ_CURRENT_VERSION);
 
   // The default factory can handle version 1 of the attributes structure. We
   // may have to change this as more fields are added to the structure
@@ -61,7 +61,7 @@ const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
 
 grpc_completion_queue* grpc_completion_queue_create_for_next(void* reserved) {
   grpc_core::ExecCtx exec_ctx;
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_completion_queue_attributes attr = {1, GRPC_CQ_NEXT,
                                            GRPC_CQ_DEFAULT_POLLING, nullptr};
   return g_default_cq_factory.vtable->create(&g_default_cq_factory, &attr);
@@ -69,7 +69,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_next(void* reserved) {
 
 grpc_completion_queue* grpc_completion_queue_create_for_pluck(void* reserved) {
   grpc_core::ExecCtx exec_ctx;
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_completion_queue_attributes attr = {1, GRPC_CQ_PLUCK,
                                            GRPC_CQ_DEFAULT_POLLING, nullptr};
   return g_default_cq_factory.vtable->create(&g_default_cq_factory, &attr);
@@ -78,7 +78,7 @@ grpc_completion_queue* grpc_completion_queue_create_for_pluck(void* reserved) {
 grpc_completion_queue* grpc_completion_queue_create_for_callback(
     grpc_completion_queue_functor* shutdown_callback, void* reserved) {
   grpc_core::ExecCtx exec_ctx;
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_completion_queue_attributes attr = {
       2, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING, shutdown_callback};
   return g_default_cq_factory.vtable->create(&g_default_cq_factory, &attr);
@@ -88,6 +88,6 @@ grpc_completion_queue* grpc_completion_queue_create(
     const grpc_completion_queue_factory* factory,
     const grpc_completion_queue_attributes* attr, void* reserved) {
   grpc_core::ExecCtx exec_ctx;
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   return factory->vtable->create(factory, attr);
 }

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

@@ -23,6 +23,7 @@
 #include <stddef.h>
 
 #include <cstdint>
+#include <type_traits>
 #include <vector>
 
 #include "src/core/util/no_destruct.h"
@@ -74,6 +75,31 @@ class BaseConnectionContextPropertiesTraits {
   }
 };
 
+template <class T, typename Ignored = void>
+struct HasRef {
+  static constexpr bool value = false;
+};
+
+template <class T>
+struct HasRef<T, std::enable_if_t<std::is_same<
+                     const T*, decltype(std::declval<T>().Ref())>::value>> {
+  static constexpr bool value = true;
+};
+
+template <class T, typename Ignored = void>
+struct HasUnref {
+  static constexpr bool value = false;
+};
+
+template <class T>
+struct HasUnref<T, std::enable_if_t<std::is_same<
+                       void, decltype(std::declval<T>().Unref())>::value>> {
+  static constexpr bool value = true;
+};
+
+template <class T>
+constexpr bool IsRefCounted = HasRef<T>::value && HasUnref<T>::value;
+
 template <typename T>
 class ConnectionContextPropertiesTraits
     : public BaseConnectionContextPropertiesTraits {
@@ -83,7 +109,13 @@ class ConnectionContextPropertiesTraits
   static T* Construct(Args&&... args) {
     return new T(std::forward<Args>(args)...);
   }
-  static void Destruct(void* p) { delete reinterpret_cast<T*>(p); }
+  static void Destruct(void* p) {
+    if constexpr (IsRefCounted<T>) {
+      reinterpret_cast<T*>(p)->Unref();
+    } else {
+      delete reinterpret_cast<T*>(p);
+    }
+  }
 
  protected:
   static const uint16_t id_;
@@ -132,13 +164,24 @@ class ConnectionContext final : public Orphanable {
   // Returns the value of a registered property. If the property is not set,
   // returns nullptr.
   template <typename Which>
-  const Which* Get() {
+  Which* Get() {
     return static_cast<Which*>(
         registered_properties()
             [connection_context_detail::ConnectionContextPropertiesTraits<
                 Which>::id()]);
   }
 
+  // Takes ownership of the value which is set.
+  template <typename Which>
+  void Set(Which* value) {
+    if constexpr (connection_context_detail::IsRefCounted<Which>) {
+      value->Ref();
+    }
+    registered_properties()
+        [connection_context_detail::ConnectionContextPropertiesTraits<
+            Which>::id()] = value;
+  }
+
   void Orphan() override;
 
   ~ConnectionContext() override;

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

@@ -37,12 +37,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -67,10 +61,16 @@
 #include "src/core/util/alloc.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time_precise.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -84,7 +84,9 @@ FilterStackCall::FilterStackCall(RefCountedPtr<Arena> arena,
            std::move(arena)),
       channel_(args.channel->RefAsSubclass<Channel>()),
       cq_(args.cq),
-      stream_op_payload_{} {}
+      stream_op_payload_{} {
+  SourceConstructed();
+}
 
 grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
                                           grpc_call** out_call) {
@@ -110,8 +112,8 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   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);
+  GRPC_DCHECK(FromC(call->c_ptr()) == call);
+  GRPC_DCHECK(FromCallStack(call->call_stack()) == call);
   *out_call = call->c_ptr();
   grpc_slice path = grpc_empty_slice();
   ScopedContext ctx(call);
@@ -148,25 +150,15 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     // collecting from when the call is created at the transport. The idea is
     // that the transport would create the call tracer and pass it in as part of
     // the metadata.
-    // TODO(yijiem): OpenCensus and internal Census is still using this way to
-    // set server call tracer. We need to refactor them to stats plugins
-    // (including removing the client channel filters).
+    ServerCallTracerInterface* server_call_tracer_from_factory = nullptr;
     if (args->server != nullptr &&
         args->server->server_call_tracer_factory() != nullptr) {
-      auto* server_call_tracer =
+      server_call_tracer_from_factory =
           args->server->server_call_tracer_factory()->CreateNewServerCallTracer(
               arena.get(), args->server->channel_args());
-      if (server_call_tracer != nullptr) {
-        // Note that we are setting both
-        // GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE and
-        // GRPC_CONTEXT_CALL_TRACER as a matter of convenience. In the future
-        // promise-based world, we would just a single tracer object for each
-        // stack (call, subchannel_call, server_call.)
-        arena->SetContext<CallTracerAnnotationInterface>(server_call_tracer);
-        arena->SetContext<CallTracerInterface>(server_call_tracer);
-      }
     }
-    (*channel_stack->stats_plugin_group)->AddServerCallTracers(arena.get());
+    (*channel_stack->stats_plugin_group)
+        ->AddServerCallTracers(arena.get(), {server_call_tracer_from_factory});
   }
 
   // initial refcount dropped by grpc_call_unref
@@ -185,7 +177,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     call->CancelWithError(error);
   }
   if (args->cq != nullptr) {
-    CHECK(args->pollset_set_alternative == nullptr)
+    GRPC_CHECK(args->pollset_set_alternative == nullptr)
         << "Only one of 'cq' and 'pollset_set_alternative' should be "
            "non-nullptr.";
     GRPC_CQ_INTERNAL_REF(args->cq, "bind");
@@ -215,7 +207,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   }
 
   if (args->send_deadline != Timestamp::InfFuture()) {
-    call->UpdateDeadline(args->send_deadline);
+    call->UpdateDeadline(args->send_deadline).IgnoreError();
   }
 
   CSliceUnref(path);
@@ -224,7 +216,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
 }
 
 void FilterStackCall::SetCompletionQueue(grpc_completion_queue* cq) {
-  CHECK(cq);
+  GRPC_CHECK(cq);
 
   if (grpc_polling_entity_pollset_set(&pollent_) != nullptr) {
     Crash("A pollset_set is already registered for this call.");
@@ -241,6 +233,7 @@ void FilterStackCall::ReleaseCall(void* call, grpc_error_handle /*error*/) {
 
 void FilterStackCall::DestroyCall(void* call, grpc_error_handle /*error*/) {
   auto* c = static_cast<FilterStackCall*>(call);
+  c->SourceDestructing();
   c->recv_initial_metadata_.Clear();
   c->recv_trailing_metadata_.Clear();
   c->receiving_slice_buffer_.reset();
@@ -273,7 +266,7 @@ void FilterStackCall::ExternalUnref() {
 
   MaybeUnpublishFromParent();
 
-  CHECK(!destroy_called_);
+  GRPC_CHECK(!destroy_called_);
   destroy_called_ = true;
   bool cancel = gpr_atm_acq_load(&received_final_op_atm_) == 0;
   if (cancel) {
@@ -337,7 +330,9 @@ void FilterStackCall::CancelWithError(grpc_error_handle error) {
   GRPC_TRACE_LOG(call_error, INFO)
       << "CancelWithError " << (is_client() ? "CLI" : "SVR") << " "
       << StatusToString(error);
-  ClearPeerString();
+  if (!IsSkipClearPeerOnCancellationEnabled()) {
+    ClearPeerString();
+  }
   InternalRef("termination");
   ResetDeadline();
   // Inform the call combiner of the cancellation, so that it can cancel
@@ -542,7 +537,6 @@ FilterStackCall::BatchControl* FilterStackCall::ReuseOrAllocateBatchControl(
     *pslot = bctl;
   }
   bctl->call_ = this;
-  bctl->call_tracer_ = arena()->GetContext<CallTracerAnnotationInterface>();
   bctl->op_.payload = &stream_op_payload_;
   return bctl;
 }
@@ -693,7 +687,7 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
   while (true) {
     gpr_atm rsr_bctlp = gpr_atm_acq_load(&call->recv_state_);
     // Should only receive initial metadata once
-    CHECK_NE(rsr_bctlp, 1);
+    GRPC_CHECK_NE(rsr_bctlp, 1);
     if (rsr_bctlp == 0) {
       // We haven't seen initial metadata and messages before, thus initial
       // metadata is received first.
@@ -1101,7 +1095,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
 
   InternalRef("completion");
   if (!is_notify_tag_closure) {
-    CHECK(grpc_cq_begin_op(cq_, notify_tag));
+    GRPC_CHECK(grpc_cq_begin_op(cq_, notify_tag));
   }
   bctl->set_pending_ops(pending_ops);
 

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

@@ -38,10 +38,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/call_combiner.h"
@@ -56,8 +52,12 @@
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -110,7 +110,7 @@ class FilterStackCall final : public Call {
 
   bool is_trailers_only() const override {
     bool result = is_trailers_only_;
-    DCHECK(!result || recv_initial_metadata_.TransportSize() == 0);
+    GRPC_DCHECK(!result || recv_initial_metadata_.TransportSize() == 0);
     return result;
   }
 
@@ -184,7 +184,6 @@ class FilterStackCall final : public Call {
   }
   struct BatchControl {
     FilterStackCall* call_ = nullptr;
-    CallTracerAnnotationInterface* call_tracer_ = nullptr;
     grpc_transport_stream_op_batch op_;
     // Share memory for cq_completion and notify_tag as they are never needed
     // simultaneously. Each byte used in this data structure count as six bytes
@@ -219,7 +218,7 @@ class FilterStackCall final : public Call {
           << "BATCH:" << this << " COMPLETE:" << PendingOpString(mask)
           << " REMAINING:" << PendingOpString(r & ~mask)
           << " (tag:" << completion_data_.notify_tag.tag << ")";
-      CHECK_NE((r & mask), 0);
+      GRPC_CHECK_NE((r & mask), 0);
       return r == mask;
     }
 

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

@@ -27,10 +27,6 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/log.h"
-#include "absl/time/clock.h"
-#include "absl/time/time.h"
 #include "src/core/client_channel/backup_poller.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/security_connector.h"
@@ -48,6 +44,10 @@
 #include "src/core/util/fork.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/thd.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
 
 // Remnants of the old plugin system
 void grpc_resolver_dns_ares_init(void);

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

@@ -26,8 +26,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -46,6 +44,8 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 // Avoid some IWYU confusion:
 // IWYU pragma: no_include "src/core/util/orphanable.h"