grpc 1.71.0 → 1.75.0

data/src/core/lib/resource_quota/memory_quota.cc

@@ -32,6 +32,8 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.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/promise/exec_ctx_wakeup_scheduler.h"
 #include "src/core/lib/promise/loop.h"
@@ -152,6 +154,15 @@ ReclamationSweep::~ReclamationSweep() {
   }
 }
 
+void ReclamationSweep::Finish() {
+  auto memory_quota = std::move(memory_quota_);
+  if (memory_quota != nullptr) {
+    auto sweep_token = sweep_token_;
+    auto waker = std::move(waker_);
+    memory_quota->FinishReclamation(sweep_token, std::move(waker));
+  }
+}
+
 //
 // ReclaimerQueue
 //
@@ -398,6 +409,20 @@ grpc_slice GrpcMemoryAllocatorImpl::MakeSlice(MemoryRequest request) {
   return slice;
 }
 
+void GrpcMemoryAllocatorImpl::FillChannelzProperties(
+    channelz::PropertyList& list) {
+  list.Set("free_bytes", free_bytes_.load(std::memory_order_relaxed))
+      .Set("taken_bytes", taken_bytes_.load(std::memory_order_relaxed))
+      .Set("chosen_shard_idx",
+           chosen_shard_idx_.load(std::memory_order_relaxed))
+      .Set("donate_back_period", donate_back_.period());
+  donate_back_.Interrupt([&list](Duration so_far) {
+    list.Set("donate_back_period_expired", so_far);
+  });
+  MutexLock lock(&reclaimer_mu_);
+  list.Set("shutdown", shutdown_);
+}
+
 //
 // BasicMemoryQuota
 //
@@ -422,7 +447,11 @@ class BasicMemoryQuota::WaitForSweepPromise {
   uint64_t token_;
 };
 
-BasicMemoryQuota::BasicMemoryQuota(std::string name) : name_(std::move(name)) {}
+BasicMemoryQuota::BasicMemoryQuota(
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
+    : channelz::DataSource(channelz_node) {
+  channelz::DataSource::SourceConstructed();
+}
 
 void BasicMemoryQuota::Start() {
   auto self = shared_from_this();
@@ -462,7 +491,7 @@ void BasicMemoryQuota::Start() {
           if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
             double free = std::max(intptr_t{0}, self->free_bytes_.load());
             size_t quota_size = self->quota_size_.load();
-            LOG(INFO) << "RQ: " << self->name_ << " perform "
+            LOG(INFO) << "RQ: " << self->name() << " perform "
                       << std::get<0>(arg)
                       << " reclamation. Available free bytes: " << free
                       << ", total quota_size: " << quota_size;
@@ -546,7 +575,7 @@ void BasicMemoryQuota::FinishReclamation(uint64_t token, Waker waker) {
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
       double free = std::max(intptr_t{0}, free_bytes_.load());
       size_t quota_size = quota_size_.load();
-      LOG(INFO) << "RQ: " << name_
+      LOG(INFO) << "RQ: " << name()
                 << " reclamation complete. Available free bytes: " << free
                 << ", total quota_size: " << quota_size;
     }
@@ -669,6 +698,44 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   return pressure_info;
 }
 
+void BasicMemoryQuota::AddData(channelz::DataSink sink) {
+  sink.AddData(
+      "memory_quota",
+      channelz::PropertyList()
+          .Set("free_bytes", free_bytes_.load(std::memory_order_relaxed))
+          .Set("quota_size", quota_size_.load(std::memory_order_relaxed))
+          .Merge(pressure_tracker_.ChannelzProperties())
+          .Set("allocators",
+               [this]() {
+                 channelz::PropertyTable table;
+                 for (auto& shard : small_allocators_.shards) {
+                   MutexLock l(&shard.shard_mu);
+                   size_t i = 0;
+                   for (auto& allocator : shard.allocators) {
+                     i++;
+                     channelz::PropertyList list;
+                     list.Set("shard", absl::StrCat("small", i));
+                     allocator->FillChannelzProperties(list);
+                     table.AppendRow(std::move(list));
+                   }
+                 }
+                 for (auto& shard : big_allocators_.shards) {
+                   MutexLock l(&shard.shard_mu);
+                   size_t i = 0;
+                   for (auto& allocator : shard.allocators) {
+                     i++;
+                     channelz::PropertyList list;
+                     list.Set("shard", absl::StrCat("big", i));
+                     allocator->FillChannelzProperties(list);
+                     table.AppendRow(std::move(list));
+                   }
+                 }
+                 return table;
+               }())
+          .Set("reclamation_counter",
+               reclamation_counter_.load(std::memory_order_relaxed)));
+}
+
 //
 // PressureTracker
 //
@@ -780,6 +847,35 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
   return report_.load(std::memory_order_relaxed);
 }
 
+channelz::PropertyList PressureController::ChannelzProperties() const {
+  return channelz::PropertyList()
+      .Set("ticks_same_pressure", ticks_same_)
+      .Set("max_ticks_same_pressure", max_ticks_same_)
+      .Set("max_pressure_reduction_per_tick", max_reduction_per_tick_ * 0.001)
+      .Set("last_pressure_was_low", last_was_low_)
+      .Set("min_pressure", min_)
+      .Set("max_pressure", max_)
+      .Set("last_control", last_control_);
+}
+
+channelz::PropertyList PressureTracker::ChannelzProperties() {
+  return channelz::PropertyList()
+      .Set("max_pressure_this_round",
+           max_this_round_.load(std::memory_order_relaxed))
+      .Set("pressure_report", report_.load(std::memory_order_relaxed))
+      .Merge([this]() {
+        channelz::PropertyList list;
+        if (!update_.Interrupt([&](Duration duration) {
+              list = controller_.ChannelzProperties();
+              list.Set("time_since_last_pressure_update", duration);
+              list.Set("pressure_update_period", update_.period());
+            })) {
+          list.Set("pressure_controller_busy", true)
+              .Set("pressure_update_period", update_.period());
+        }
+        return list;
+      }());
+}
 }  // namespace memory_quota_detail
 
 //

data/src/core/lib/resource_quota/memory_quota.h

@@ -35,6 +35,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/activity.h"
@@ -112,9 +113,7 @@ class ReclamationSweep {
   // Explicit finish for users that wish to write it.
   // Just destroying the object is enough, but sometimes the additional
   // explicitness is warranted.
-  void Finish() {
-    [](ReclamationSweep) {}(std::move(*this));
-  }
+  void Finish();
 
  private:
   std::shared_ptr<BasicMemoryQuota> memory_quota_;
@@ -235,6 +234,7 @@ class PressureController {
   double Update(double error);
   // Textual representation of the controller.
   std::string DebugString() const;
+  channelz::PropertyList ChannelzProperties() const;
 
  private:
   // How many update periods have we reached the same decision in a row?
@@ -266,6 +266,8 @@ class PressureTracker {
  public:
   double AddSampleAndGetControlValue(double sample);
 
+  channelz::PropertyList ChannelzProperties();
+
  private:
   std::atomic<double> max_this_round_{0.0};
   std::atomic<double> report_{0.0};
@@ -281,7 +283,8 @@ static constexpr size_t kBigAllocatorThreshold = 0.5 * 1024 * 1024;
 static constexpr size_t kSmallAllocatorThreshold = 0.1 * 1024 * 1024;
 
 class BasicMemoryQuota final
-    : public std::enable_shared_from_this<BasicMemoryQuota> {
+    : public std::enable_shared_from_this<BasicMemoryQuota>,
+      public channelz::DataSource {
  public:
   // Data about current memory pressure.
   struct PressureInfo {
@@ -294,7 +297,9 @@ class BasicMemoryQuota final
     size_t max_recommended_allocation_size = 0;
   };
 
-  explicit BasicMemoryQuota(std::string name);
+  explicit BasicMemoryQuota(
+      RefCountedPtr<channelz::ResourceQuotaNode> channelz_node);
+  ~BasicMemoryQuota() { channelz::DataSource::SourceDestructing(); }
 
   // Start the reclamation activity.
   void Start();
@@ -326,7 +331,9 @@ class BasicMemoryQuota final
   ReclaimerQueue* reclaimer_queue(size_t i) { return &reclaimers_[i]; }
 
   // The name of this quota
-  absl::string_view name() const { return name_; }
+  absl::string_view name() const { return channelz_node()->name(); }
+
+  void AddData(channelz::DataSink sink) override;
 
  private:
   friend class ReclamationSweep;
@@ -380,8 +387,6 @@ class BasicMemoryQuota final
   std::atomic<uint64_t> reclamation_counter_{0};
   // Memory pressure smoothing
   memory_quota_detail::PressureTracker pressure_tracker_;
-  // The name of this quota - used for debugging/tracing/etc..
-  std::string name_;
 };
 
 // MemoryAllocatorImpl grants the owner the ability to allocate memory from an
@@ -455,6 +460,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     return chosen_shard_idx_.fetch_add(1, std::memory_order_relaxed);
   }
 
+  void FillChannelzProperties(channelz::PropertyList& list);
+
  private:
   static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
@@ -552,8 +559,9 @@ class MemoryOwner final : public MemoryAllocator {
 class MemoryQuota final
     : public grpc_event_engine::experimental::MemoryAllocatorFactory {
  public:
-  explicit MemoryQuota(std::string name)
-      : memory_quota_(std::make_shared<BasicMemoryQuota>(std::move(name))) {
+  explicit MemoryQuota(RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
+      : memory_quota_(
+            std::make_shared<BasicMemoryQuota>(std::move(channelz_node))) {
     memory_quota_->Start();
   }
   ~MemoryQuota() override {
@@ -582,8 +590,9 @@ class MemoryQuota final
 };
 
 using MemoryQuotaRefPtr = std::shared_ptr<MemoryQuota>;
-inline MemoryQuotaRefPtr MakeMemoryQuota(std::string name) {
-  return std::make_shared<MemoryQuota>(std::move(name));
+inline MemoryQuotaRefPtr MakeMemoryQuota(
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node) {
+  return std::make_shared<MemoryQuota>(std::move(channelz_node));
 }
 
 std::vector<std::shared_ptr<BasicMemoryQuota>> AllMemoryQuotas();

data/src/core/lib/resource_quota/periodic_update.cc

@@ -22,6 +22,20 @@
 
 namespace grpc_core {
 
+bool PeriodicUpdate::Interrupt(absl::FunctionRef<void(Duration)> f) {
+  int64_t old_value = updates_remaining_.load(std::memory_order_acquire);
+  while (true) {
+    if (old_value <= 1) return false;
+    if (!updates_remaining_.compare_exchange_weak(old_value, 0,
+                                                  std::memory_order_acquire)) {
+      continue;
+    }
+    f(Timestamp::Now() - period_start_);
+    updates_remaining_.store(old_value, std::memory_order_release);
+    return true;
+  }
+}
+
 bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   if (period_start_ == Timestamp::ProcessEpoch()) {
     period_start_ = Timestamp::Now();

data/src/core/lib/resource_quota/periodic_update.h

@@ -48,6 +48,14 @@ class PeriodicUpdate {
     return false;
   }
 
+  // Interrupt execution: call f as if the period expired, and then continue
+  // from where we left off.
+  // Returns false if this was not possible (eg we were at the end of a tick)
+  // Argument to the callback is the amount of time expired so far.
+  bool Interrupt(absl::FunctionRef<void(Duration)> f);
+
+  Duration period() const { return period_; }
+
  private:
   bool MaybeEndPeriod(absl::FunctionRef<void(Duration)> f);
 

data/src/core/lib/resource_quota/resource_quota.cc

@@ -16,18 +16,29 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/no_destruct.h"
+#include "src/core/util/single_set_ptr.h"
+
 namespace grpc_core {
 
 ResourceQuota::ResourceQuota(std::string name)
-    : memory_quota_(MakeMemoryQuota(std::move(name))),
+    : channelz_node_(
+          MakeRefCounted<channelz::ResourceQuotaNode>(std::move(name))),
+      memory_quota_(MakeMemoryQuota(channelz_node_)),
       thread_quota_(MakeRefCounted<ThreadQuota>()) {}
 
 ResourceQuota::~ResourceQuota() = default;
 
+namespace {
+NoDestruct<SingleSetRefCountedPtr<ResourceQuota>> default_resource_quota{};
+}  // namespace
+
 ResourceQuotaRefPtr ResourceQuota::Default() {
-  static auto default_resource_quota =
-      MakeResourceQuota("default_resource_quota").release();
-  return default_resource_quota->Ref();
+  return default_resource_quota->GetOrCreate("default_resource_quota");
+}
+
+void ResourceQuota::TestOnlyResetDefaultResourceQuota() {
+  default_resource_quota->Reset();
 }
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/resource_quota.h

@@ -23,6 +23,7 @@
 #include <utility>
 
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/thread_quota.h"
 #include "src/core/util/cpp_impl_of.h"
@@ -53,6 +54,7 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
 
   // The default global resource quota
   static ResourceQuotaRefPtr Default();
+  static void TestOnlyResetDefaultResourceQuota();
 
   static int ChannelArgsCompare(const ResourceQuota* a,
                                 const ResourceQuota* b) {
@@ -60,6 +62,7 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
   }
 
  private:
+  RefCountedPtr<channelz::ResourceQuotaNode> channelz_node_;
   MemoryQuotaRefPtr memory_quota_;
   RefCountedPtr<ThreadQuota> thread_quota_;
 };

data/src/core/lib/security/authorization/evaluate_args.cc

@@ -23,9 +23,9 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "src/core/credentials/transport/tls/tls_utils.h"
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"

data/src/core/lib/security/authorization/evaluate_args.h

@@ -23,9 +23,9 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -24,13 +24,13 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
 
@@ -92,8 +92,7 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
 
 absl::Status GrpcServerAuthzFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, GrpcServerAuthzFilter* filter) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
-      "GrpcServerAuthzFilter::Call::OnClientInitialMetadata");
+  GRPC_LATENT_SEE_SCOPE("GrpcServerAuthzFilter::Call::OnClientInitialMetadata");
   if (!filter->IsAuthorized(md)) {
     return absl::PermissionDeniedError("Unauthorized RPC request rejected.");
   }

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -25,8 +25,8 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/authorization_policy_provider.h"
 #include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {

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

@@ -294,6 +294,11 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND MutableSlice
     return MutableSlice(NoCheck{}, grpc_slice_split_head(c_slice_ptr(), n));
   }
 
+  MutableSlice TakeFirstNoInline(size_t n) {
+    return MutableSlice(NoCheck{},
+                        grpc_slice_split_head_no_inline(c_slice_ptr(), n));
+  }
+
   // Iterator access to the underlying bytes
   uint8_t* begin() { return mutable_data(); }
   uint8_t* end() { return mutable_data() + size(); }
@@ -432,6 +437,12 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
   static Slice FromExternalString(absl::string_view str) {
     return FromStaticString(str);
   }
+
+  static Slice ZeroContentsWithLength(size_t length) {
+    grpc_slice backing = grpc_slice_malloc(length);
+    memset(GRPC_SLICE_START_PTR(backing), 0, length);
+    return Slice(backing);
+  }
 };
 
 }  // namespace grpc_core

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

@@ -112,6 +112,12 @@ class SliceBuffer {
     grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
   }
 
+  /// Copy the first n bytes of the SliceBuffer into a memory pointed to by
+  /// dst. The original SliceBuffer remains unchanged.
+  void CopyFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_copy_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
   /// Removes/deletes the last n bytes in the SliceBuffer and add it to the
   /// other SliceBuffer
   void MoveLastNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {

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

@@ -55,10 +55,12 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/call_finalization.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/channelz/channelz.h"
-#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -86,8 +88,6 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -191,7 +191,7 @@ void Call::PublishToParent(Call* parent) {
         cc->sibling_prev->child_->sibling_next = this;
   }
   if (parent->Completed()) {
-    CancelWithError(absl::CancelledError());
+    CancelWithError(absl::CancelledError("CANCELLED"));
   }
 }
 
@@ -215,16 +215,20 @@ void Call::MaybeUnpublishFromParent() {
 }
 
 void Call::CancelWithStatus(grpc_status_code status, const char* description) {
-  // copying 'description' is needed to ensure the grpc_call_cancel_with_status
-  // guarantee that can be short-lived.
-  // TODO(ctiller): change to
-  // absl::Status(static_cast<absl::StatusCode>(status), description)
-  // (ie remove the set_int, set_str).
-  CancelWithError(grpc_error_set_int(
-      grpc_error_set_str(
-          absl::Status(static_cast<absl::StatusCode>(status), description),
-          StatusStrProperty::kGrpcMessage, description),
-      StatusIntProperty::kRpcStatus, status));
+  if (!IsErrorFlattenEnabled()) {
+    CancelWithError(grpc_error_set_int(
+        grpc_error_set_str(
+            absl::Status(static_cast<absl::StatusCode>(status), description),
+            StatusStrProperty::kGrpcMessage, description),
+        StatusIntProperty::kRpcStatus, status));
+    return;
+  }
+  if (status == GRPC_STATUS_OK) {
+    VLOG(2) << "CancelWithStatus() called with OK status, using UNKNOWN";
+    status = GRPC_STATUS_UNKNOWN;
+  }
+  CancelWithError(
+      absl::Status(static_cast<absl::StatusCode>(status), description));
 }
 
 void Call::PropagateCancellationToChildren() {
@@ -238,7 +242,7 @@ void Call::PropagateCancellationToChildren() {
         Call* next_child_call = child->child_->sibling_next;
         if (child->cancellation_is_inherited_) {
           child->InternalRef("propagate_cancel");
-          child->CancelWithError(absl::CancelledError());
+          child->CancelWithError(absl::CancelledError("CANCELLED"));
           child->InternalUnref("propagate_cancel");
         }
         child = next_child_call;
@@ -414,7 +418,8 @@ grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
     return GRPC_CALL_ERROR;
   }
   grpc_core::ExecCtx exec_ctx;
-  grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
   return GRPC_CALL_OK;
 }
 
@@ -435,7 +440,8 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
 }
 
 void grpc_call_cancel_internal(grpc_call* call) {
-  grpc_core::Call::FromC(call)->CancelWithError(absl::CancelledError());
+  grpc_core::Call::FromC(call)->CancelWithError(
+      absl::CancelledError("CANCELLED"));
 }
 
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
@@ -484,13 +490,13 @@ grpc_call_error grpc_call_start_batch_and_execute(grpc_call* call,
 }
 
 void grpc_call_tracer_set(grpc_call* call,
-                          grpc_core::ClientCallTracer* tracer) {
-  grpc_core::Arena* arena = grpc_call_get_arena(call);
-  return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
+                          grpc_core::ClientCallTracerInterface* tracer) {
+  grpc_call_get_arena(call)
+      ->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
 }
 
-void grpc_call_tracer_set_and_manage(grpc_call* call,
-                                     grpc_core::ClientCallTracer* tracer) {
+void grpc_call_tracer_set_and_manage(
+    grpc_call* call, grpc_core::ClientCallTracerInterface* tracer) {
   grpc_core::Arena* arena = grpc_call_get_arena(call);
   arena->ManagedNew<ClientCallTracerWrapper>(tracer);
   return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);

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

@@ -262,7 +262,8 @@ grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
                          size_t nops);
 
-void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
+void grpc_call_tracer_set(grpc_call* call,
+                          grpc_core::ClientCallTracerInterface* tracer);
 
 // Sets call tracer on the call and manages its life by using the call's arena.
 // When using this API, the tracer will be destroyed by grpc_call arena when
@@ -271,8 +272,8 @@ void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
 // Arena to manage the lifetime of the call tracer. Python needs this API
 // because the tracer was created within a separate shared object library which
 // doesn't have access to core functions like arena->ManagedNew<>.
-void grpc_call_tracer_set_and_manage(grpc_call* call,
-                                     grpc_core::ClientCallTracer* tracer);
+void grpc_call_tracer_set_and_manage(
+    grpc_call* call, grpc_core::ClientCallTracerInterface* tracer);
 
 void* grpc_call_tracer_get(grpc_call* call);
 
@@ -287,11 +288,11 @@ uint8_t grpc_call_is_client(grpc_call* call);
 
 class ClientCallTracerWrapper {
  public:
-  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracer* tracer)
+  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracerInterface* tracer)
       : tracer_(tracer) {}
 
  private:
-  std::unique_ptr<grpc_core::ClientCallTracer> tracer_;
+  std::unique_ptr<grpc_core::ClientCallTracerInterface> tracer_;
 };
 
 // Return an appropriate compression algorithm for the requested compression \a

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

@@ -46,7 +46,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
@@ -56,8 +58,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/match.h"

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

@@ -44,6 +44,9 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/message.h"
+#include "src/core/call/metadata.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/map.h"
@@ -51,9 +54,6 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/message.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {

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

@@ -30,6 +30,8 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/call_arena_allocator.h"
+#include "src/core/call/call_destination.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -37,8 +39,6 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_arena_allocator.h"
-#include "src/core/lib/transport/call_destination.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/ref_counted.h"