grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -28,15 +28,18 @@
 #include <set>
 #include <string>
 #include <type_traits>
+#include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 
@@ -69,6 +72,11 @@ struct CompareFusedChannelFiltersByName {
   }
 };
 
+struct Node {
+  const grpc_channel_filter* filter;
+  int next;
+};
+
 }  // namespace
 
 ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::After(
@@ -177,9 +185,8 @@ class ChannelInit::DependencyTracker {
 
   FilterRegistration* Next() {
     if (ready_dependencies_.empty()) {
-      CHECK_EQ(nodes_taken_, nodes_.size()) << "Unresolvable graph of channel "
-                                               "filters:\n"
-                                            << GraphString();
+      GRPC_CHECK_EQ(nodes_taken_, nodes_.size())
+          << "Unresolvable graph of channel filters :\n " << GraphString();
       return nullptr;
     }
     auto next = ready_dependencies_.top();
@@ -189,13 +196,13 @@ class ChannelInit::DependencyTracker {
       // Constraint: if we use ordering other than default, then we must have an
       // unambiguous pick. If there is ambiguity, we must fix it by adding
       // explicit ordering constraints.
-      CHECK_NE(next.node->ordering(),
-               ready_dependencies_.top().node->ordering())
+      GRPC_CHECK_NE(next.node->ordering(),
+                    ready_dependencies_.top().node->ordering())
           << "Ambiguous ordering between " << next.node->name() << " and "
           << ready_dependencies_.top().node->name();
     }
     for (Node* dependent : next.node->dependents) {
-      CHECK_GT(dependent->waiting_dependencies, 0u);
+      GRPC_CHECK_GT(dependent->waiting_dependencies, 0u);
       --dependent->waiting_dependencies;
       if (dependent->waiting_dependencies == 0) {
         ready_dependencies_.emplace(dependent);
@@ -220,7 +227,7 @@ class ChannelInit::DependencyTracker {
 
   absl::Span<const UniqueTypeName> DependenciesFor(UniqueTypeName name) const {
     auto it = nodes_.find(name);
-    CHECK(it != nodes_.end()) << "Filter " << name.name() << " not found";
+    GRPC_CHECK(it != nodes_.end()) << "Filter " << name.name() << " not found";
     return it->second.all_dependencies;
   }
 
@@ -274,21 +281,29 @@ std::vector<ChannelInit::FilterNode> ChannelInit::SelectFiltersByPredicate(
   return filter_list;
 }
 
-void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
-                               const std::vector<Filter>& fused_filters) {
+void ChannelInit::MergeFusedFilters(ChannelStackBuilder* builder,
+                                    const std::vector<Filter>& fused_filters) {
   int i = 0;
   int j = 0;
+  auto& stack = *builder->mutable_stack();
+  std::vector<Node> filter_list;
+  for (const auto filter : stack) {
+    filter_list.push_back({filter, ++i});
+  }
+  filter_list.back().next = -1;
   // Iterate through fused filters (by size) and check if a given fused filter
   // can replace one of the existing sequence of filters.
   for (auto& curr_fused_filter : fused_filters) {
     i = 0;
     while (i != -1 && filter_list[i].next != -1) {
-      std::string fused_prefix(filter_list[i].curr->name.name());
+      std::string fused_prefix(
+          NameFromChannelFilter(filter_list[i].filter).name());
       j = filter_list[i].next;
       do {
-        absl::StrAppend(&fused_prefix, "+", filter_list[j].curr->name.name());
+        absl::StrAppend(&fused_prefix, "+",
+                        NameFromChannelFilter(filter_list[j].filter).name());
         if (fused_prefix == curr_fused_filter.name.name()) {
-          filter_list[i].curr = &curr_fused_filter;
+          filter_list[i].filter = curr_fused_filter.filter;
           filter_list[i].next = filter_list[j].next;
         }
         j = filter_list[j].next;
@@ -296,6 +311,13 @@ void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
       i = filter_list[i].next;
     }
   }
+  // Replace the stack with the new filter list.
+  stack.clear();
+  i = 0;
+  while (i != -1 && !filter_list.empty()) {
+    builder->AppendFilter(filter_list[i].filter);
+    i = filter_list[i].next;
+  };
 }
 
 void ChannelInit::AppendFiltersToBuilder(
@@ -311,7 +333,7 @@ std::tuple<std::vector<ChannelInit::Filter>, std::vector<ChannelInit::Filter>>
 ChannelInit::SortFilterRegistrationsByDependencies(
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
         filter_registrations,
-    grpc_channel_stack_type type) {
+    grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering) {
   // Phase 1: Build a map from filter to the set of filters that must be
   // initialized before it.
   // We order this map (and the set of dependent filters) by filter name to
@@ -322,10 +344,10 @@ ChannelInit::SortFilterRegistrationsByDependencies(
   std::vector<Filter> terminal_filters;
   for (const auto& registration : filter_registrations) {
     if (registration->terminal_) {
-      CHECK(registration->after_.empty());
-      CHECK(registration->before_.empty());
-      CHECK(!registration->before_all_);
-      CHECK_EQ(registration->ordering_, Ordering::kDefault);
+      GRPC_CHECK(registration->after_.empty());
+      GRPC_CHECK(registration->before_.empty());
+      GRPC_CHECK(!registration->before_all_);
+      GRPC_CHECK_EQ(registration->ordering_, Ordering::kDefault);
       terminal_filters.emplace_back(
           registration->name_, registration->filter_, nullptr,
           std::move(registration->predicates_), registration->version_,
@@ -362,6 +384,19 @@ ChannelInit::SortFilterRegistrationsByDependencies(
         std::move(registration->predicates_), registration->version_,
         registration->ordering_, registration->registration_source_);
   }
+
+  for (const auto& filter : filters) {
+    auto after = dependencies.DependenciesFor(filter.name);
+    std::string ordering_str;
+    if (!after.empty()) {
+      ordering_str = absl::StrCat("after ", absl::StrJoin(after, ", "));
+    }
+    absl::StrAppend(&ordering_str, " [", filter.ordering, "/", filter.version,
+                    "]");
+    filter_ordering.AppendRow(channelz::PropertyList()
+                                  .Set("name", filter.name.name())
+                                  .Set("ordering", ordering_str));
+  }
   // Log out the graph we built if that's been requested.
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     PrintChannelStackTrace(type, filter_registrations, dependencies, filters,
@@ -376,7 +411,7 @@ std::vector<ChannelInit::Filter> ChannelInit::SortFusedFilterRegistrations(
   std::vector<FilterRegistration*> fused_filter_registrations;
   std::vector<Filter> filters;
   for (const auto& registration : filter_registrations) {
-    CHECK(!registration->terminal_);
+    GRPC_CHECK(!registration->terminal_);
     fused_filter_registrations.push_back(registration.get());
   }
   std::sort(fused_filter_registrations.begin(),
@@ -406,9 +441,10 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     if (post_processors[i] == nullptr) continue;
     post_processor_functions.emplace_back(std::move(post_processors[i]));
   }
+  channelz::PropertyTable filter_ordering;
 
-  auto sorted_filters =
-      SortFilterRegistrationsByDependencies(filter_registrations, type);
+  auto sorted_filters = SortFilterRegistrationsByDependencies(
+      filter_registrations, type, filter_ordering);
   std::vector<Filter> filters = std::move(std::get<0>(sorted_filters));
   std::vector<Filter> terminal_filters = std::move(std::get<1>(sorted_filters));
 
@@ -432,7 +468,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   }
   return StackConfig{std::move(filters), std::move(fused_filters),
                      std::move(terminal_filters),
-                     std::move(post_processor_functions)};
+                     std::move(post_processor_functions), filter_ordering};
 };
 
 void ChannelInit::PrintChannelStackTrace(
@@ -574,13 +610,17 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
     return false;
   }
 
-  MergeFilters(filter_list, stack_config.fused_filters);
   AppendFiltersToBuilder(filter_list, builder);
   AppendFiltersToBuilder(terminal_filter_list, builder);
 
   for (const auto& post_processor : stack_config.post_processors) {
     post_processor(*builder);
   }
+
+  // Only perform the merge with fused filters operation after running
+  // through all the post processors. This ensures that modifications made by
+  // post processors are taken into account before finding fusions to match.
+  MergeFusedFilters(builder, stack_config.fused_filters);
   return true;
 }
 
@@ -600,4 +640,21 @@ void ChannelInit::AddToInterceptionChainBuilder(
   }
 }
 
+void ChannelInit::AddData(channelz::DataSink sink,
+                          grpc_channel_stack_type type) const {
+  const auto& stack_config = stack_configs_[type];
+  sink.AddData(
+      "channel_stack_filters",
+      channelz::PropertyList().Set("elements", stack_config.filter_ordering));
+  sink.AddData("fused_filters",
+               channelz::PropertyList().Set("elements", [&stack_config]() {
+                 channelz::PropertyTable elements;
+                 for (const auto& filter : stack_config.fused_filters) {
+                   elements.AppendRow(channelz::PropertyList().Set(
+                       "name", filter.name.name()));
+                 }
+                 return elements;
+               }()));
+}
+
 }  // namespace grpc_core

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

@@ -29,14 +29,16 @@
 #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"
 
 /// This module provides a way for plugins (and the grpc core library itself)
@@ -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);
     }
@@ -338,7 +350,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 +373,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 +397,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 +439,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 +448,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 +458,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,7 +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"
@@ -46,6 +45,7 @@
 #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"
@@ -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;