grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -32,15 +32,17 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
-#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/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/periodic_update.h"
+#include "src/core/lib/resource_quota/telemetry.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
@@ -134,7 +136,7 @@ class ReclaimerQueue {
     explicit Handle(F reclaimer, std::shared_ptr<State> state)
         : sweep_(new SweepFn<F>(std::move(reclaimer), std::move(state))) {}
     ~Handle() override {
-      DCHECK_EQ(sweep_.load(std::memory_order_relaxed), nullptr);
+      GRPC_DCHECK_EQ(sweep_.load(std::memory_order_relaxed), nullptr);
     }
 
     Handle(const Handle&) = delete;
@@ -273,6 +275,11 @@ class PressureTracker {
   std::atomic<double> report_{0.0};
   PeriodicUpdate update_{Duration::Seconds(1)};
   PressureController controller_{100, 3};
+
+  const double target_memory_pressure_ =
+      ConfigVars::Get().ExperimentalTargetMemoryPressure();
+  const double memory_pressure_threshold_ =
+      ConfigVars::Get().ExperimentalMemoryPressureThreshold();
 };
 }  // namespace memory_quota_detail
 
@@ -284,7 +291,8 @@ static constexpr size_t kSmallAllocatorThreshold = 0.1 * 1024 * 1024;
 
 class BasicMemoryQuota final
     : public std::enable_shared_from_this<BasicMemoryQuota>,
-      public channelz::DataSource {
+      public channelz::DataSource,
+      public GaugeProvider<ResourceQuotaDomain> {
  public:
   // Data about current memory pressure.
   struct PressureInfo {
@@ -298,8 +306,9 @@ class BasicMemoryQuota final
   };
 
   explicit BasicMemoryQuota(
-      RefCountedPtr<channelz::ResourceQuotaNode> channelz_node);
-  ~BasicMemoryQuota() { channelz::DataSource::SourceDestructing(); }
+      RefCountedPtr<channelz::ResourceQuotaNode> channelz_node,
+      InstrumentStorageRefPtr<ResourceQuotaDomain> telemetry_storage);
+  ~BasicMemoryQuota();
 
   // Start the reclamation activity.
   void Start();
@@ -335,6 +344,12 @@ class BasicMemoryQuota final
 
   void AddData(channelz::DataSink sink) override;
 
+  void PopulateGaugeData(GaugeSink<ResourceQuotaDomain>& sink) override;
+
+  InstrumentStorage<ResourceQuotaDomain>* telemetry_storage() const {
+    return telemetry_storage_.get();
+  }
+
  private:
   friend class ReclamationSweep;
   class WaitForSweepPromise;
@@ -387,6 +402,7 @@ class BasicMemoryQuota final
   std::atomic<uint64_t> reclamation_counter_{0};
   // Memory pressure smoothing
   memory_quota_detail::PressureTracker pressure_tracker_;
+  const InstrumentStorageRefPtr<ResourceQuotaDomain> telemetry_storage_;
 };
 
 // MemoryAllocatorImpl grants the owner the ability to allocate memory from an
@@ -440,7 +456,7 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   template <typename F>
   void PostReclaimer(ReclamationPass pass, F fn) {
     MutexLock lock(&reclaimer_mu_);
-    CHECK(!shutdown_);
+    GRPC_CHECK(!shutdown_);
     InsertReclaimer(static_cast<size_t>(pass), std::move(fn));
   }
 
@@ -462,6 +478,10 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
 
   void FillChannelzProperties(channelz::PropertyList& list);
 
+  InstrumentStorage<ResourceQuotaDomain>* telemetry_storage() const {
+    return memory_quota_->telemetry_storage();
+  }
+
  private:
   static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
@@ -537,12 +557,23 @@ class MemoryOwner final : public MemoryAllocator {
   // Is this object valid (ie has not been moved out of or reset)
   bool is_valid() const { return impl() != nullptr; }
 
-  static double memory_pressure_high_threshold() { return 0.99; }
+  static double memory_pressure_high_threshold_reject_new_streams() {
+    return 0.99;
+  }
+
+  static double memory_pressure_high_threshold_reject_new_connections() {
+    return 0.99;
+  }
 
-  // Return true if the controlled memory pressure is high.
-  bool IsMemoryPressureHigh() const {
+  // Return true if the controlled memory pressure is high enough to reject new
+  // streams.
+  bool RejectNewStreamsUnderHighMemoryPressure() const {
     return GetPressureInfo().pressure_control_value >
-           memory_pressure_high_threshold();
+           memory_pressure_high_threshold_reject_new_streams();
+  }
+
+  InstrumentStorage<ResourceQuotaDomain>* telemetry_storage() const {
+    return impl()->telemetry_storage();
   }
 
  private:
@@ -560,8 +591,9 @@ class MemoryQuota final
     : public grpc_event_engine::experimental::MemoryAllocatorFactory {
  public:
   explicit MemoryQuota(RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
-      : memory_quota_(
-            std::make_shared<BasicMemoryQuota>(std::move(channelz_node))) {
+      : memory_quota_(std::make_shared<BasicMemoryQuota>(
+            std::move(channelz_node),
+            ResourceQuotaDomain::GetStorage(channelz_node->name()))) {
     memory_quota_->Start();
   }
   ~MemoryQuota() override {
@@ -579,9 +611,11 @@ class MemoryQuota final
   // Resize the quota to new_size.
   void SetSize(size_t new_size) { memory_quota_->SetSize(new_size); }
 
-  bool IsMemoryPressureHigh() const {
+  // Return true if the controlled memory pressure is high enough to reject new
+  // connections.
+  bool RejectNewConnectionsUnderHighMemoryPressure() const {
     return memory_quota_->GetPressureInfo().pressure_control_value >
-           MemoryOwner::memory_pressure_high_threshold();
+           MemoryOwner::memory_pressure_high_threshold_reject_new_connections();
   }
 
  private:
@@ -597,8 +631,6 @@ inline MemoryQuotaRefPtr MakeMemoryQuota(
 
 std::vector<std::shared_ptr<BasicMemoryQuota>> AllMemoryQuotas();
 
-void SetContainerMemoryPressure(double pressure);
-
 double ContainerMemoryPressure();
 
 }  // namespace grpc_core

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

@@ -0,0 +1,54 @@
+// 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_QUOTA_TELEMETRY_H
+#define GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_TELEMETRY_H
+
+#include "src/core/telemetry/instrument.h"
+
+namespace grpc_core {
+
+class ResourceQuotaDomain final : public InstrumentDomain<ResourceQuotaDomain> {
+ public:
+  using Backend = HighContentionBackend;
+  static constexpr auto kLabels = Labels("grpc.resource_quota");
+
+  static inline const auto kCallsDropped = RegisterCounter(
+      "grpc.resource_quota.calls_dropped",
+      "EXPERIMENTAL.  Number of calls dropped due to resource quota "
+      "exceeded",
+      "calls");
+  static inline const auto kCallsRejected = RegisterCounter(
+      "grpc.resource_quota.calls_rejected",
+      "EXPERIMENTAL.  Number of calls rejected due to resource quota "
+      "exceeded",
+      "calls");
+  static inline const auto kConnectionsDropped = RegisterCounter(
+      "grpc.resource_quota.connections_dropped",
+      "EXPERIMENTAL.  Number of connections dropped due to resource quota "
+      "exceeded",
+      "connections");
+  static inline const auto kInstantaneousMemoryPressure = RegisterDoubleGauge(
+      "grpc.resource_quota.instantaneous_memory_pressure",
+      "The current instantaneously measured memory pressure.", "ratio");
+  static inline const auto kMemoryPressureControlValue = RegisterDoubleGauge(
+      "grpc.resource_quota.memory_pressure_control_value",
+      "A control value that can be used to scale buffer sizes up or down to "
+      "adjust memory pressure to our target set point.",
+      "ratio");
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_TELEMETRY_H

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_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,12 +26,12 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.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/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_core {
@@ -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/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/stdout_logger.cc

@@ -22,12 +22,12 @@
 #include <memory>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 namespace experimental {
@@ -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/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

@@ -48,7 +48,6 @@
 #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"
@@ -98,6 +97,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"
@@ -119,9 +119,10 @@ Call::Call(bool is_client, Timestamp send_deadline, RefCountedPtr<Arena> arena)
     : 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<Call>(this);
 }
 
@@ -148,8 +149,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 +308,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);
@@ -413,7 +414,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 +431,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 +492,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

@@ -30,7 +30,6 @@
 
 #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"
@@ -45,6 +44,7 @@
 #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"

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

@@ -40,7 +40,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -60,6 +59,7 @@
 #include "src/core/lib/surface/validate_metadata.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"
 
 namespace grpc_core {
@@ -215,7 +215,7 @@ bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
 void EndOpImmediately(grpc_completion_queue* cq, void* notify_tag,
                       bool is_notify_tag_closure) {
   if (!is_notify_tag_closure) {
-    CHECK(grpc_cq_begin_op(cq, notify_tag));
+    GRPC_CHECK(grpc_cq_begin_op(cq, notify_tag));
     grpc_cq_end_op(
         cq, notify_tag, absl::OkStatus(),
         [](void*, grpc_cq_completion* completion) { gpr_free(completion); },

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

@@ -40,7 +40,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -55,6 +54,7 @@
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -428,7 +428,7 @@ class MessageReceiver {
 
   template <typename Puller>
   auto MakeBatchOp(const grpc_op& op, Puller* puller) {
-    CHECK_EQ(recv_message_, nullptr);
+    GRPC_CHECK_EQ(recv_message_, nullptr);
     recv_message_ = op.data.recv_message.recv_message;
     return [this, puller]() mutable {
       return Map(puller->PullMessage(),

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

@@ -22,7 +22,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -31,6 +30,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -102,7 +102,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
                                     grpc_completion_queue* completion_queue,
                                     grpc_slice method, const grpc_slice* host,
                                     gpr_timespec deadline, void* reserved) {
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->CreateCall(
       parent_call, propagation_mask, completion_queue, nullptr,
@@ -119,7 +119,7 @@ void* grpc_channel_register_call(grpc_channel* channel, const char* method,
   GRPC_TRACE_LOG(api, INFO) << "grpc_channel_register_call(channel=" << channel
                             << ", method=" << method << ", host=" << host
                             << ", reserved=" << reserved << ")";
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->RegisterCall(method, host);
 }
@@ -208,6 +208,6 @@ void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_ping(channel=" << channel << ", cq=" << cq
       << ", tag=" << tag << ", reserved=" << reserved << ")";
-  CHECK_EQ(reserved, nullptr);
+  GRPC_CHECK_EQ(reserved, nullptr);
   grpc_core::Channel::FromC(channel)->Ping(cq, tag);
 }

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

@@ -21,7 +21,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "src/core/channelz/channelz.h"
@@ -47,6 +46,7 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/transport/endpoint_transport.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -199,10 +199,14 @@ grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
                                            GRPC_STATUS_INTERNAL,
                                            "Failed to create client channel");
   }
-  std::unique_ptr<EventEngine::Endpoint> endpoint =
-      supports_fd->CreateEndpointFromFd(
-          fd, ChannelArgsEndpointConfig(channel_args));
-  return CreateChannelFromEndpoint(std::move(endpoint), creds,
+  auto endpoint = supports_fd->CreateEndpointFromFd(
+      fd, ChannelArgsEndpointConfig(channel_args));
+  if (!endpoint.ok()) {
+    return grpc_lame_client_channel_create(
+        "fake:created-from-endpoint", GRPC_STATUS_INTERNAL,
+        std::string(endpoint.status().message()).c_str());
+  }
+  return CreateChannelFromEndpoint(std::move(endpoint).value(), creds,
                                    channel_args.ToC().get());
 }
 }  // namespace experimental
@@ -230,7 +234,7 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
   auto channel =
       grpc_core::ChannelCreate(target == nullptr ? "" : target, std::move(args),
                                GRPC_CLIENT_LAME_CHANNEL, nullptr);
-  CHECK(channel.ok());
+  GRPC_CHECK(channel.ok());
   return channel->release()->c_ptr();
 }