grpc 1.75.0 → 1.78.1

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

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -38,7 +38,7 @@ bool ThreadQuota::Reserve(size_t num_threads) {
 
 void ThreadQuota::Release(size_t num_threads) {
   MutexLock lock(&mu_);
-  CHECK(num_threads <= allocated_);
+  GRPC_CHECK(num_threads <= allocated_);
   allocated_ -= num_threads;
 }
 

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

@@ -20,10 +20,10 @@
 #include <cstddef>
 #include <limits>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
 
 namespace grpc_core {
 

data/src/core/lib/resource_tracker/resource_tracker.cc

@@ -0,0 +1,33 @@
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/lib/resource_tracker/resource_tracker.h"
+
+#include <atomic>
+
+namespace grpc_core {
+
+namespace {
+std::atomic<ResourceTracker*> g_resource_tracker(nullptr);
+}  // namespace
+
+ResourceTracker* ResourceTracker::Get() {
+  return g_resource_tracker.load(std::memory_order_acquire);
+}
+
+void ResourceTracker::Set(ResourceTracker* tracker) {
+  g_resource_tracker.store(tracker, std::memory_order_release);
+}
+
+}  // namespace grpc_core

data/src/core/lib/resource_tracker/resource_tracker.h

@@ -0,0 +1,46 @@
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_RESOURCE_TRACKER_RESOURCE_TRACKER_H
+#define GRPC_SRC_CORE_LIB_RESOURCE_TRACKER_RESOURCE_TRACKER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+#include <vector>
+
+#include "absl/status/statusor.h"
+
+namespace grpc_core {
+
+// Interface for tracking and retrieving resource usage metrics.
+class ResourceTracker {
+ public:
+  virtual ~ResourceTracker() = default;
+
+  static ResourceTracker* Get();
+  static void Set(ResourceTracker* tracker);
+
+  // Returns a list of metric names that this tracker can provide.
+  virtual std::vector<std::string> GetMetrics() const = 0;
+
+  // Retrieves the current value of a specific metric.
+  // Returns NotFoundError if the metric_name is not supported.
+  virtual absl::StatusOr<double> GetMetricValue(
+      const std::string& metric_name) const = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_RESOURCE_TRACKER_RESOURCE_TRACKER_H

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

@@ -26,13 +26,13 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
+#include "src/core/lib/security/authorization/stdout_logger.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/sync.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/security/authorization/stdout_logger.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 namespace experimental {
@@ -44,15 +44,15 @@ AuditLoggerRegistry* AuditLoggerRegistry::registry = new AuditLoggerRegistry();
 AuditLoggerRegistry::AuditLoggerRegistry() {
   auto factory = std::make_unique<StdoutAuditLoggerFactory>();
   absl::string_view name = factory->name();
-  CHECK(logger_factories_map_.emplace(name, std::move(factory)).second);
+  GRPC_CHECK(logger_factories_map_.emplace(name, std::move(factory)).second);
 }
 
 void AuditLoggerRegistry::RegisterFactory(
     std::unique_ptr<AuditLoggerFactory> factory) {
-  CHECK(factory != nullptr);
+  GRPC_CHECK(factory != nullptr);
   MutexLock lock(mu);
   absl::string_view name = factory->name();
-  CHECK(
+  GRPC_CHECK(
       registry->logger_factories_map_.emplace(name, std::move(factory)).second);
 }
 
@@ -77,7 +77,7 @@ std::unique_ptr<AuditLogger> AuditLoggerRegistry::CreateAuditLogger(
     std::unique_ptr<AuditLoggerFactory::Config> config) {
   MutexLock lock(mu);
   auto it = registry->logger_factories_map_.find(config->name());
-  CHECK(it != registry->logger_factories_map_.end());
+  GRPC_CHECK(it != registry->logger_factories_map_.end());
   return it->second->CreateAuditLogger(std::move(config));
 }
 

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

@@ -26,10 +26,10 @@
 #include <map>
 #include <memory>
 
+#include "src/core/util/sync.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 namespace experimental {

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

@@ -19,11 +19,11 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
 #include "src/core/util/dual_ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/string_view.h"
 
 struct grpc_authorization_policy_provider
     : public grpc_core::DualRefCounted<grpc_authorization_policy_provider> {

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

@@ -18,17 +18,17 @@
 #include <grpc/support/port_platform.h>
 #include <string.h>
 
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#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/slice/slice.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 
 namespace grpc_core {
 

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

@@ -22,10 +22,10 @@
 #include <string>
 #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 "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -20,9 +20,9 @@
 #include <map>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/lib/security/authorization/audit_logging.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -58,7 +58,7 @@ GrpcAuthorizationEngine::GrpcAuthorizationEngine(Rbac policy)
   for (auto& logger_config : policy.logger_configs) {
     auto logger =
         AuditLoggerRegistry::CreateAuditLogger(std::move(logger_config));
-    CHECK(logger != nullptr);
+    GRPC_CHECK(logger != nullptr);
     audit_loggers_.push_back(std::move(logger));
   }
 }

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

@@ -21,9 +21,6 @@
 #include <string>
 #include <utility>
 
-#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"
@@ -33,6 +30,9 @@
 #include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_join.h"
 
 namespace grpc_core {
 

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

@@ -18,7 +18,6 @@
 #include <grpc/grpc_security.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -28,6 +27,7 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 
@@ -55,6 +55,9 @@ class GrpcServerAuthzFilter final
     static inline const NoInterceptor OnClientToServerHalfClose;
     static inline const NoInterceptor OnServerToClientMessage;
     static inline const NoInterceptor OnFinalize;
+    channelz::PropertyList ChannelzProperties() {
+      return channelz::PropertyList();
+    }
   };
 
  private:

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

@@ -20,12 +20,12 @@
 
 #include <string>
 
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
 
 namespace grpc_core {
 

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

@@ -22,7 +22,7 @@
 #include <memory>
 #include <string>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -65,8 +65,8 @@ StdoutAuditLoggerFactory::ParseAuditLoggerConfig(const Json&) {
 std::unique_ptr<AuditLogger> StdoutAuditLoggerFactory::CreateAuditLogger(
     std::unique_ptr<AuditLoggerFactory::Config> config) {
   // Sanity check.
-  CHECK(config != nullptr);
-  CHECK(config->name() == name());
+  GRPC_CHECK(config != nullptr);
+  GRPC_CHECK_EQ(config->name(), name());
   return std::make_unique<StdoutAuditLogger>();
 }
 

data/src/core/lib/slice/percent_encoding.cc

@@ -24,8 +24,8 @@
 #include <cstdint>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/util/bitset.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 

data/src/core/lib/slice/slice.cc

@@ -25,10 +25,10 @@
 
 #include <new>
 
-#include "absl/log/check.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/util/memory.h"
+#include "absl/log/check.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));

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

@@ -25,12 +25,12 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/string.h"
+#include "absl/log/check.h"
+#include "absl/strings/string_view.h"
 
 // Herein lies grpc_core::Slice and its team of thin wrappers around grpc_slice.
 // They aim to keep you safe by providing strong guarantees around lifetime and

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

@@ -26,8 +26,8 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 

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

@@ -26,10 +26,10 @@
 #include <cstddef>
 #include <string>
 
+#include "src/core/util/memory.h"
 #include "absl/hash/hash.h"
 #include "absl/log/check.h"
 #include "absl/strings/string_view.h"
-#include "src/core/util/memory.h"
 
 // Returns a pointer to the first slice in the slice buffer without giving
 // ownership to or a reference count on that slice.

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

@@ -24,9 +24,9 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/util/grpc_check.h"
 
 int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
                                  grpc_byte_buffer* buffer) {
@@ -92,7 +92,7 @@ grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader) {
     memcpy(&(outbuf[bytes_read]), GRPC_SLICE_START_PTR(in_slice), slice_length);
     bytes_read += slice_length;
     grpc_core::CSliceUnref(in_slice);
-    CHECK(bytes_read <= input_size);
+    GRPC_CHECK(bytes_read <= input_size);
   }
 
   return out_slice;

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

@@ -47,19 +47,12 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#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/config/config_vars.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -98,6 +91,7 @@
 #include "src/core/util/cpp_impl_of.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/match.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -105,6 +99,13 @@
 #include "src/core/util/sync.h"
 #include "src/core/util/time_precise.h"
 #include "src/core/util/useful.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -116,15 +117,41 @@ using GrpcClosure = Closure;
 // Call
 
 Call::Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena)
-    : arena_(std::move(arena)),
+    : channelz::DataSource(ConfigVars::Get().ChannelzCallTracer()
+                               ? MakeRefCounted<channelz::CallNode>()
+                               : nullptr),
+      arena_(std::move(arena)),
       send_deadline_(send_deadline),
       is_client_(is_client) {
-  DCHECK_NE(arena_.get(), nullptr);
-  DCHECK_NE(arena_->GetContext<grpc_event_engine::experimental::EventEngine>(),
-            nullptr);
+  GRPC_DCHECK_NE(arena_.get(), nullptr);
+  GRPC_DCHECK_NE(
+      arena_->GetContext<grpc_event_engine::experimental::EventEngine>(),
+      nullptr);
+  arena_->SetContext<channelz::CallNode>(
+      DownCast<channelz::CallNode*>(channelz_node().get()));
   arena_->SetContext<Call>(this);
 }
 
+void Call::AddData(channelz::DataSink sink) {
+  channelz::PropertyList properties;
+  properties.Set("is_client", is_client_)
+      .Set("send_deadline", send_deadline_)
+      .Set("start_time", Timestamp::FromCycleCounterRoundDown(start_time_))
+      .Set("cancellation_is_inherited", cancellation_is_inherited_)
+      .Set("traced", traced_)
+      .Set("encodings_accepted_by_peer",
+           encodings_accepted_by_peer_.ToString());
+  {
+    MutexLock lock(&peer_mu_);
+    properties.Set("peer_string", peer_string_.as_string_view());
+  }
+  {
+    MutexLock lock(&deadline_mu_);
+    properties.Set("deadline", deadline_);
+  }
+  sink.AddData("call", properties);
+}
+
 Call::ParentCall* Call::GetOrCreateParentCall() {
   ParentCall* p = parent_call_.load(std::memory_order_acquire);
   if (p == nullptr) {
@@ -148,8 +175,8 @@ absl::Status Call::InitParent(Call* parent, uint32_t propagation_mask) {
   child_ = arena()->New<ChildCall>(parent);
 
   parent->InternalRef("child");
-  CHECK(is_client_);
-  CHECK(!parent->is_client_);
+  GRPC_CHECK(is_client_);
+  GRPC_CHECK(!parent->is_client_);
 
   if (propagation_mask & GRPC_PROPAGATE_DEADLINE) {
     send_deadline_ = std::min(send_deadline_, parent->send_deadline_);
@@ -307,7 +334,7 @@ void Call::ProcessIncomingInitialMetadata(grpc_metadata_batch& md) {
     HandleCompressionAlgorithmDisabled(compression_algorithm);
   }
   // GRPC_COMPRESS_NONE is always set.
-  DCHECK(encodings_accepted_by_peer_.IsSet(GRPC_COMPRESS_NONE));
+  GRPC_DCHECK(encodings_accepted_by_peer_.IsSet(GRPC_COMPRESS_NONE));
   if (GPR_UNLIKELY(!encodings_accepted_by_peer_.IsSet(compression_algorithm))) {
     if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       HandleCompressionAlgorithmNotAccepted(compression_algorithm);
@@ -336,28 +363,30 @@ void Call::HandleCompressionAlgorithmDisabled(
                                      GRPC_STATUS_UNIMPLEMENTED));
 }
 
-void Call::UpdateDeadline(Timestamp deadline) {
+grpc_error_handle Call::UpdateDeadline(Timestamp deadline) {
   ReleasableMutexLock lock(&deadline_mu_);
   GRPC_TRACE_LOG(call, INFO)
       << "[call " << this << "] UpdateDeadline from=" << deadline_.ToString()
       << " to=" << deadline.ToString();
-  if (deadline >= deadline_) return;
+  if (deadline >= deadline_) return absl::OkStatus();
   if (deadline < Timestamp::Now()) {
     lock.Release();
-    CancelWithError(grpc_error_set_int(
+    grpc_error_handle error = grpc_error_set_int(
         absl::DeadlineExceededError("Deadline Exceeded"),
-        StatusIntProperty::kRpcStatus, GRPC_STATUS_DEADLINE_EXCEEDED));
-    return;
+        StatusIntProperty::kRpcStatus, GRPC_STATUS_DEADLINE_EXCEEDED);
+    CancelWithError(error);
+    return error;
   }
   auto* event_engine =
       arena_->GetContext<grpc_event_engine::experimental::EventEngine>();
   if (deadline_ != Timestamp::InfFuture()) {
-    if (!event_engine->Cancel(deadline_task_)) return;
+    if (!event_engine->Cancel(deadline_task_)) return absl::OkStatus();
   } else {
     InternalRef("deadline");
   }
   deadline_ = deadline;
   deadline_task_ = event_engine->RunAfter(deadline - Timestamp::Now(), this);
+  return absl::OkStatus();
 }
 
 void Call::ResetDeadline() {
@@ -413,7 +442,7 @@ char* grpc_call_get_peer(grpc_call* call) {
 grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_call_cancel(call=" << call << ", reserved=" << reserved << ")";
-  CHECK_EQ(reserved, nullptr);
+  GRPC_CHECK_EQ(reserved, nullptr);
   if (call == nullptr) {
     return GRPC_CALL_ERROR;
   }
@@ -430,7 +459,7 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_call_cancel_with_status(c=" << c << ", status=" << (int)status
       << ", description=" << description << ", reserved=" << reserved << ")";
-  CHECK_EQ(reserved, nullptr);
+  GRPC_CHECK_EQ(reserved, nullptr);
   if (c == nullptr) {
     return GRPC_CALL_ERROR;
   }
@@ -491,21 +520,22 @@ grpc_call_error grpc_call_start_batch_and_execute(grpc_call* call,
 
 void grpc_call_tracer_set(grpc_call* call,
                           grpc_core::ClientCallTracerInterface* tracer) {
-  grpc_call_get_arena(call)
-      ->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
+  auto* arena = grpc_call_get_arena(call);
+  arena->SetContext<grpc_core::CallSpan>(
+      grpc_core::WrapClientCallTracer(tracer, arena));
 }
 
 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);
+  arena->SetContext<grpc_core::CallSpan>(
+      grpc_core::WrapClientCallTracer(tracer, arena));
 }
 
 void* grpc_call_tracer_get(grpc_call* call) {
   grpc_core::Arena* arena = grpc_call_get_arena(call);
-  auto* call_tracer =
-      arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
+  auto* call_tracer = arena->GetContext<grpc_core::CallSpan>();
   return call_tracer;
 }
 

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

@@ -28,10 +28,6 @@
 
 #include <optional>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/functional/function_ref.h"
-#include "absl/log/check.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -45,9 +41,13 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
 #include "src/core/util/time_precise.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
 
 typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
@@ -81,7 +81,11 @@ struct ArenaContextType<census_context> {
 
 class Call : public CppImplOf<Call, grpc_call>,
              public grpc_event_engine::experimental::EventEngine::
-                 Closure /* for deadlines */ {
+                 Closure /* for deadlines */,
+             public channelz::DataSource
+/* for channelz - derived implementations must call
+   SourceConstructed/SourceDestructing */
+{
  public:
   Arena* arena() const { return arena_.get(); }
   bool is_client() const { return is_client_; }
@@ -102,7 +106,8 @@ class Call : public CppImplOf<Call, grpc_call>,
   virtual void InternalRef(const char* reason) = 0;
   virtual void InternalUnref(const char* reason) = 0;
 
-  void UpdateDeadline(Timestamp deadline) ABSL_LOCKS_EXCLUDED(deadline_mu_);
+  grpc_error_handle UpdateDeadline(Timestamp deadline)
+      ABSL_LOCKS_EXCLUDED(deadline_mu_);
   void ResetDeadline() ABSL_LOCKS_EXCLUDED(deadline_mu_);
   Timestamp deadline() {
     MutexLock lock(&deadline_mu_);
@@ -202,6 +207,8 @@ class Call : public CppImplOf<Call, grpc_call>,
   virtual void SetIncomingCompressionAlgorithm(
       grpc_compression_algorithm algorithm) = 0;
 
+  void AddData(channelz::DataSink sink) override;
+
  private:
   const RefCountedPtr<Arena> arena_;
   std::atomic<ParentCall*> parent_call_{nullptr};