grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/client_channel/client_channel_filter.cc

@@ -38,7 +38,6 @@
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -96,6 +95,7 @@
 #include "src/core/service_config/service_config_impl.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/json/json.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/status_helper.h"
@@ -336,8 +336,8 @@ class DynamicTerminationFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    CHECK(args->is_last);
-    CHECK(elem->filter == &kFilterVtable);
+    GRPC_CHECK(args->is_last);
+    GRPC_CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) DynamicTerminationFilter(args->channel_args);
     return absl::OkStatus();
   }
@@ -494,7 +494,7 @@ class ClientChannelFilter::SubchannelWrapper final
         << " for subchannel " << subchannel_.get();
     GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "SubchannelWrapper");
 #ifndef NDEBUG
-    DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
+    GRPC_DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
 #endif
     if (chand_->channelz_node_ != nullptr) {
       auto* subchannel_node = subchannel_->channelz_node();
@@ -530,7 +530,7 @@ class ClientChannelFilter::SubchannelWrapper final
         auto* subchannel_node = subchannel_->channelz_node();
         if (subchannel_node != nullptr) {
           auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-          CHECK(it != chand_->subchannel_refcount_map_.end());
+          GRPC_CHECK(it != chand_->subchannel_refcount_map_.end());
           --it->second;
           if (it->second == 0) {
             subchannel_node->RemoveParent(chand_->channelz_node_);
@@ -538,6 +538,20 @@ class ClientChannelFilter::SubchannelWrapper final
           }
         }
       }
+      if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
+        // We need to make sure that the internal subchannel gets unreffed
+        // inside of the WorkSerializer, so that updates to the local
+        // subchannel pool are properly synchronized.  To that end, we
+        // drop our ref to the internal subchannel here.  We also cancel
+        // any watchers that were not properly cancelled, in case any of
+        // them are holding a ref to the internal subchannel.
+        for (const auto& [_, watcher] : watcher_map_) {
+          subchannel_->CancelConnectivityStateWatch(watcher);
+        }
+        watcher_map_.clear();
+        data_watchers_.clear();
+        subchannel_.reset();
+      }
       WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
     });
   }
@@ -546,10 +560,10 @@ class ClientChannelFilter::SubchannelWrapper final
       std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto& watcher_wrapper = watcher_map_[watcher.get()];
-    CHECK_EQ(watcher_wrapper, nullptr);
+    GRPC_CHECK_EQ(watcher_wrapper, nullptr);
     watcher_wrapper = new WatcherWrapper(
         std::move(watcher),
-        RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
+        WeakRefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
     subchannel_->WatchConnectivityState(
         RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface>(
             watcher_wrapper));
@@ -558,7 +572,7 @@ class ClientChannelFilter::SubchannelWrapper final
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto it = watcher_map_.find(watcher);
-    CHECK(it != watcher_map_.end());
+    GRPC_CHECK(it != watcher_map_.end());
     subchannel_->CancelConnectivityStateWatch(it->second);
     watcher_map_.erase(it);
   }
@@ -575,7 +589,7 @@ class ClientChannelFilter::SubchannelWrapper final
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get())
         ->SetSubchannel(subchannel_.get());
-    CHECK(data_watchers_.insert(std::move(watcher)).second);
+    GRPC_CHECK(data_watchers_.insert(std::move(watcher)).second);
   }
 
   void CancelDataWatcher(DataWatcherInterface* watcher) override
@@ -609,7 +623,7 @@ class ClientChannelFilter::SubchannelWrapper final
     WatcherWrapper(
         std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
             watcher,
-        RefCountedPtr<SubchannelWrapper> parent)
+        WeakRefCountedPtr<SubchannelWrapper> parent)
         : watcher_(std::move(watcher)), parent_(std::move(parent)) {}
 
     ~WatcherWrapper() override {
@@ -621,7 +635,6 @@ class ClientChannelFilter::SubchannelWrapper final
       GRPC_TRACE_LOG(client_channel, INFO)
           << "chand=" << parent_->chand_
           << ": connectivity change for subchannel wrapper " << parent_.get()
-          << " subchannel " << parent_->subchannel_.get()
           << "hopping into work_serializer";
       auto self = RefAsSubclass<WatcherWrapper>();
       parent_->chand_->work_serializer_->Run(
@@ -682,7 +695,7 @@ class ClientChannelFilter::SubchannelWrapper final
 
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher_;
-    RefCountedPtr<SubchannelWrapper> parent_;
+    WeakRefCountedPtr<SubchannelWrapper> parent_;
   };
 
   // A heterogenous lookup comparator for data watchers that allows
@@ -736,7 +749,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
   {
     MutexLock lock(&chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
-    CHECK(chand->external_watchers_[on_complete] == nullptr);
+    GRPC_CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
     chand->external_watchers_[on_complete] =
         RefAsSubclass<ExternalConnectivityWatcher>(
@@ -996,8 +1009,8 @@ class ClientChannelFilter::ClientChannelControlHelper final
 
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
-  CHECK(args->is_last);
-  CHECK(elem->filter == &kFilter);
+  GRPC_CHECK(args->is_last);
+  GRPC_CHECK(elem->filter == &kFilter);
   grpc_error_handle error;
   new (elem->channel_data) ClientChannelFilter(args, &error);
   return error;
@@ -1015,11 +1028,7 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
   if (args.GetBool(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL).value_or(false)) {
     return MakeRefCounted<LocalSubchannelPool>();
   }
-  if (IsShardGlobalConnectionPoolEnabled()) {
-    return GlobalSubchannelPool::instance();
-  } else {
-    return LegacyGlobalSubchannelPool::instance();
-  }
+  return GlobalSubchannelPool::instance();
 }
 
 }  // namespace
@@ -1189,7 +1198,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   // - A channel arg, in which case we check that the specified policy exists
   //   and accepts an empty config. If not, we revert to using pick_first
   //   lb_policy
-  CHECK(lb_policy_config.ok());
+  GRPC_CHECK(lb_policy_config.ok());
   return std::move(*lb_policy_config);
 }
 
@@ -1458,7 +1467,7 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
   blackboard_ = std::move(new_blackboard);
   RefCountedPtr<DynamicFilters> dynamic_filters =
       DynamicFilters::Create(new_args, std::move(filters), blackboard_.get());
-  CHECK(dynamic_filters != nullptr);
+  GRPC_CHECK(dynamic_filters != nullptr);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1488,7 +1497,7 @@ void ClientChannelFilter::CreateResolverLocked() {
       std::make_unique<ResolverResultHandler>(this));
   // Since the validity of the args was checked when the channel was created,
   // CreateResolver() must return a non-null result.
-  CHECK(resolver_ != nullptr);
+  GRPC_CHECK(resolver_ != nullptr);
   UpdateStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status(),
                     "started resolving");
   resolver_->StartLocked();
@@ -1598,7 +1607,7 @@ T HandlePickResult(
   }
   auto* drop_pick =
       std::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
-  CHECK_NE(drop_pick, nullptr);
+  GRPC_CHECK_NE(drop_pick, nullptr);
   return drop_func(drop_pick);
 }
 
@@ -1691,7 +1700,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       }
     } else {
       // Disconnect.
-      CHECK(disconnect_error_.ok());
+      GRPC_CHECK(disconnect_error_.ok());
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1709,7 +1718,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
 void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
                                            grpc_transport_op* op) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  CHECK(op->set_accept_stream == false);
+  GRPC_CHECK(op->set_accept_stream == false);
   // Handle bind_pollset.
   if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(chand->interested_parties_, op->bind_pollset);
@@ -1871,7 +1880,7 @@ std::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
   }
   // If the call was queued, add trace annotation.
   if (was_queued) {
-    auto* call_tracer = arena()->GetContext<CallTracerAnnotationInterface>();
+    auto* call_tracer = arena()->GetContext<CallSpan>();
     if (call_tracer != nullptr) {
       call_tracer->RecordAnnotation("Delayed name resolution complete.");
     }
@@ -1928,7 +1937,7 @@ ClientChannelFilter::FilterBasedCallData::FilterBasedCallData(
 ClientChannelFilter::FilterBasedCallData::~FilterBasedCallData() {
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    CHECK_EQ(pending_batches_[i], nullptr);
+    GRPC_CHECK_EQ(pending_batches_[i], nullptr);
   }
 }
 
@@ -2076,7 +2085,7 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesAdd(
       << "chand=" << chand() << " calld=" << this
       << ": adding pending batch at index " << idx;
   grpc_transport_stream_op_batch*& pending = pending_batches_[idx];
-  CHECK_EQ(pending, nullptr);
+  GRPC_CHECK_EQ(pending, nullptr);
   pending = batch;
 }
 
@@ -2096,7 +2105,7 @@ void ClientChannelFilter::FilterBasedCallData::FailPendingBatchInCallCombiner(
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_call)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2290,8 +2299,7 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
   ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const override;
 
-  ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
-      const override;
+  CallAttemptTracer* GetCallAttemptTracer() const override;
 
  private:
   LoadBalancedCall* lb_call_;
@@ -2308,7 +2316,7 @@ ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttribute(
   return service_config_call_data->GetCallAttribute(type);
 }
 
-ClientCallTracerInterface::CallAttemptTracer*
+CallAttemptTracer*
 ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttemptTracer()
     const {
   return lb_call_->call_attempt_tracer();
@@ -2365,13 +2373,13 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
 
 namespace {
 
-ClientCallTracerInterface::CallAttemptTracer* CreateCallAttemptTracer(
-    Arena* arena, bool is_transparent_retry) {
-  auto* call_tracer = DownCast<ClientCallTracerInterface*>(
-      arena->GetContext<CallTracerAnnotationInterface>());
+CallAttemptTracer* CreateCallAttemptTracer(Arena* arena,
+                                           bool is_transparent_retry) {
+  auto* call_tracer = arena->GetContext<ClientCallTracer>();
   if (call_tracer == nullptr) return nullptr;
-  auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
-  arena->SetContext<CallTracerInterface>(tracer);
+  auto* tracer = WrapCallAttemptTracer(
+      call_tracer->StartNewAttempt(is_transparent_retry), arena);
+  arena->SetContext<CallTracer>(tracer);
   return tracer;
 }
 
@@ -2516,11 +2524,11 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
-  CHECK(connected_subchannel_ == nullptr);
+  GRPC_CHECK(connected_subchannel_ == nullptr);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  CHECK_NE(path, nullptr);
+  GRPC_CHECK_NE(path, nullptr);
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
@@ -2535,7 +2543,7 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
             << "chand=" << chand_ << " lb_call=" << this
             << ": LB pick succeeded: subchannel="
             << complete_pick->subchannel.get();
-        CHECK(complete_pick->subchannel != nullptr);
+        GRPC_CHECK(complete_pick->subchannel != nullptr);
         // Grab a ref to the connected subchannel while we're still
         // holding the data plane mutex.
         SubchannelWrapper* subchannel =
@@ -2620,7 +2628,7 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::
     ~FilterBasedLoadBalancedCall() {
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    CHECK_EQ(pending_batches_[i], nullptr);
+    GRPC_CHECK_EQ(pending_batches_[i], nullptr);
   }
   if (on_call_destruction_complete_ != nullptr) {
     ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
@@ -2661,7 +2669,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesAdd(
   GRPC_TRACE_LOG(client_channel_lb_call, INFO)
       << "chand=" << chand() << " lb_call=" << this
       << ": adding pending batch at index " << idx;
-  CHECK_EQ(pending_batches_[idx], nullptr);
+  GRPC_CHECK_EQ(pending_batches_[idx], nullptr);
   pending_batches_[idx] = batch;
 }
 
@@ -2681,7 +2689,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   failure_error_ = error;
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)) {
     size_t num_batches = 0;

data/src/core/client_channel/client_channel_filter.h

@@ -373,7 +373,7 @@ class ClientChannelFilter::LoadBalancedCall
 
  protected:
   ClientChannelFilter* chand() const { return chand_; }
-  ClientCallTracerInterface::CallAttemptTracer* call_attempt_tracer() const {
+  CallAttemptTracer* call_attempt_tracer() const {
     return call_attempt_tracer_;
   }
   ConnectedSubchannel* connected_subchannel() const {
@@ -434,7 +434,7 @@ class ClientChannelFilter::LoadBalancedCall
   // previous attempt yet leading to a situation where we have two active call
   // attempt tracers, and so we cannot rely on the arena to give us the right
   // tracer when performing cleanup.
-  ClientCallTracerInterface::CallAttemptTracer* call_attempt_tracer_;
+  CallAttemptTracer* call_attempt_tracer_;
 
   absl::AnyInvocable<void()> on_commit_;
 

data/src/core/client_channel/client_channel_internal.h

@@ -22,13 +22,13 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/unique_type_name.h"
 
 //
@@ -54,8 +54,7 @@ class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
 
   virtual ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const = 0;
-  virtual ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
-      const = 0;
+  virtual CallAttemptTracer* GetCallAttemptTracer() const = 0;
 };
 
 // Internal type for ServiceConfigCallData.  Handles call commits.
@@ -65,7 +64,7 @@ class ClientChannelServiceConfigCallData final : public ServiceConfigCallData {
       : ServiceConfigCallData(arena) {}
 
   void SetOnCommit(absl::AnyInvocable<void()> on_commit) {
-    CHECK(on_commit_ == nullptr);
+    GRPC_CHECK(on_commit_ == nullptr);
     on_commit_ = std::move(on_commit);
   }
 

data/src/core/client_channel/config_selector.h

@@ -24,7 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "src/core/call/interception_chain.h"
@@ -35,6 +34,7 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/service_config/service_config.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/unique_type_name.h"
@@ -100,7 +100,7 @@ class DefaultConfigSelector final : public ConfigSelector {
     // The client channel code ensures that this will never be null.
     // If neither the resolver nor the client application provide a
     // config, a default empty config will be used.
-    DCHECK(service_config_ != nullptr);
+    GRPC_DCHECK(service_config_ != nullptr);
   }
 
   UniqueTypeName name() const override {
@@ -110,7 +110,7 @@ class DefaultConfigSelector final : public ConfigSelector {
 
   absl::Status GetCallConfig(GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
-    CHECK_NE(path, nullptr);
+    GRPC_CHECK_NE(path, nullptr);
     auto* parsed_method_configs =
         service_config_->GetMethodParsedConfigVector(path->c_slice());
     args.service_config_call_data->SetServiceConfig(service_config_,

data/src/core/client_channel/dynamic_filters.cc

@@ -22,7 +22,6 @@
 #include <new>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -32,6 +31,7 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 // Conversion between call and call stack.
@@ -80,8 +80,8 @@ void DynamicFilters::Call::StartTransportStreamOpBatch(
 }
 
 void DynamicFilters::Call::SetAfterCallStackDestroy(grpc_closure* closure) {
-  CHECK_EQ(after_call_stack_destroy_, nullptr);
-  CHECK_NE(closure, nullptr);
+  GRPC_CHECK_EQ(after_call_stack_destroy_, nullptr);
+  GRPC_CHECK_NE(closure, nullptr);
   after_call_stack_destroy_ = closure;
 }
 

data/src/core/client_channel/global_subchannel_pool.cc

@@ -26,43 +26,6 @@
 
 namespace grpc_core {
 
-RefCountedPtr<LegacyGlobalSubchannelPool>
-LegacyGlobalSubchannelPool::instance() {
-  static LegacyGlobalSubchannelPool* p = new LegacyGlobalSubchannelPool();
-  return p->RefAsSubclass<LegacyGlobalSubchannelPool>();
-}
-
-RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::RegisterSubchannel(
-    const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  if (it != subchannel_map_.end()) {
-    RefCountedPtr<Subchannel> existing = it->second->RefIfNonZero();
-    if (existing != nullptr) return existing;
-  }
-  subchannel_map_[key] = constructed.get();
-  return constructed;
-}
-
-void LegacyGlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
-                                                      Subchannel* subchannel) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  // delete only if key hasn't been re-registered to a different subchannel
-  // between strong-unreffing and unregistration of subchannel.
-  if (it != subchannel_map_.end() && it->second == subchannel) {
-    subchannel_map_.erase(it);
-  }
-}
-
-RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::FindSubchannel(
-    const SubchannelKey& key) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  if (it == subchannel_map_.end()) return nullptr;
-  return it->second->RefIfNonZero();
-}
-
 RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
   static GlobalSubchannelPool* p = new GlobalSubchannelPool();
   return p->RefAsSubclass<GlobalSubchannelPool>();

data/src/core/client_channel/global_subchannel_pool.h

@@ -30,33 +30,6 @@
 
 namespace grpc_core {
 
-// The global subchannel pool. It shares subchannels among channels. There
-// should be only one instance of this class.
-class LegacyGlobalSubchannelPool final : public SubchannelPoolInterface {
- public:
-  // Gets the singleton instance.
-  static RefCountedPtr<LegacyGlobalSubchannelPool> instance();
-
-  // Implements interface methods.
-  RefCountedPtr<Subchannel> RegisterSubchannel(
-      const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-  void UnregisterSubchannel(const SubchannelKey& key,
-                            Subchannel* subchannel) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-  RefCountedPtr<Subchannel> FindSubchannel(const SubchannelKey& key) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-
- private:
-  LegacyGlobalSubchannelPool() {}
-  ~LegacyGlobalSubchannelPool() override {}
-
-  // A map from subchannel key to subchannel.
-  std::map<SubchannelKey, Subchannel*> subchannel_map_ ABSL_GUARDED_BY(mu_);
-  // To protect subchannel_map_.
-  Mutex mu_;
-};
-
 // The global subchannel pool. It shares subchannels among channels. There
 // should be only one instance of this class.
 class GlobalSubchannelPool final : public SubchannelPoolInterface {

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -29,10 +29,12 @@ namespace grpc_core {
 namespace {
 
 void MaybeCreateCallAttemptTracer(bool is_transparent_retry) {
-  auto* call_tracer = MaybeGetContext<ClientCallTracerInterface>();
+  auto* arena = MaybeGetContext<Arena>();
+  if (arena == nullptr) return;
+  auto* call_tracer = MaybeGetContext<ClientCallTracer>();
   if (call_tracer == nullptr) return;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
-  SetContext<CallTracerInterface>(tracer);
+  SetContext<CallAttemptTracer>(WrapCallAttemptTracer(tracer, arena));
 }
 
 class LbCallState : public ClientChannelLbCallState {
@@ -47,9 +49,8 @@ class LbCallState : public ClientChannelLbCallState {
     return service_config_call_data->GetCallAttribute(type);
   }
 
-  ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
-      const override {
-    return GetContext<ClientCallTracerInterface::CallAttemptTracer>();
+  CallAttemptTracer* GetCallAttemptTracer() const override {
+    return GetContext<CallAttemptTracer>();
   }
 };
 
@@ -240,8 +241,7 @@ void LoadBalancedCallDestination::StartCall(
               }
               // If it was queued, add a trace annotation.
               if (was_queued) {
-                auto* tracer = MaybeGetContext<
-                    ClientCallTracerInterface::CallAttemptTracer>();
+                auto* tracer = MaybeGetContext<CallAttemptTracer>();
                 if (tracer != nullptr) {
                   tracer->RecordAnnotation("Delayed LB pick complete.");
                 }

data/src/core/client_channel/local_subchannel_pool.cc

@@ -22,8 +22,8 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/client_channel/subchannel.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -33,7 +33,7 @@ RefCountedPtr<Subchannel> LocalSubchannelPool::RegisterSubchannel(
   // Because this pool is only accessed under the client channel's work
   // serializer, and because FindSubchannel is checked before invoking
   // RegisterSubchannel, no such subchannel should exist in the map.
-  CHECK(it == subchannel_map_.end());
+  GRPC_CHECK(it == subchannel_map_.end());
   subchannel_map_[key] = constructed.get();
   return constructed;
 }
@@ -44,8 +44,8 @@ void LocalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   // Because this subchannel pool is accessed only under the client
   // channel's work serializer, any subchannel created by RegisterSubchannel
   // will be deleted from the map in UnregisterSubchannel.
-  CHECK(it != subchannel_map_.end());
-  CHECK(it->second == subchannel);
+  GRPC_CHECK(it != subchannel_map_.end());
+  GRPC_CHECK(it->second == subchannel);
   subchannel_map_.erase(it);
 }
 

data/src/core/client_channel/retry_filter.h

@@ -27,7 +27,6 @@
 #include <new>
 #include <optional>
 
-#include "absl/log/check.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_service_config.h"
 #include "src/core/client_channel/retry_throttle.h"
@@ -36,6 +35,7 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
 
@@ -88,8 +88,8 @@ class RetryFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    CHECK(args->is_last);
-    CHECK(elem->filter == &kVtable);
+    GRPC_CHECK(args->is_last);
+    GRPC_CHECK(elem->filter == &kVtable);
     new (elem->channel_data) RetryFilter(*args);
     return absl::OkStatus();
   }

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -20,7 +20,6 @@
 #include <memory>
 #include <new>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -44,6 +43,7 @@
 #include "src/core/util/backoff.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -1502,7 +1502,7 @@ RetryFilter::LegacyCallData::~LegacyCallData() {
   FreeAllCachedSendOpData();
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    CHECK_EQ(pending_batches_[i].batch, nullptr);
+    GRPC_CHECK_EQ(pending_batches_[i].batch, nullptr);
   }
 }
 
@@ -1731,7 +1731,7 @@ RetryFilter::LegacyCallData::PendingBatchesAdd(
   GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
                               << ": adding pending batch at index " << idx;
   PendingBatch* pending = &pending_batches_[idx];
-  CHECK_EQ(pending->batch, nullptr);
+  GRPC_CHECK_EQ(pending->batch, nullptr);
   pending->batch = batch;
   pending->send_ops_cached = false;
   // Update state in calld about pending batches.
@@ -1810,7 +1810,7 @@ void RetryFilter::LegacyCallData::FailPendingBatchInCallCombiner(
 
 // This is called via the call combiner, so access to calld is synchronized.
 void RetryFilter::LegacyCallData::PendingBatchesFail(grpc_error_handle error) {
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(retry)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -1887,7 +1887,7 @@ void RetryFilter::LegacyCallData::StartRetryTimer(
   // Compute backoff delay.
   Duration next_attempt_timeout;
   if (server_pushback.has_value()) {
-    CHECK(*server_pushback >= Duration::Zero());
+    GRPC_CHECK(*server_pushback >= Duration::Zero());
     next_attempt_timeout = *server_pushback;
     retry_backoff_.Reset();
   } else {