grpc 1.75.0 → 1.78.1

data/src/core/lib/promise/wait_set.h

@@ -19,10 +19,10 @@
 
 #include <utility>
 
-#include "absl/container/flat_hash_set.h"
-#include "absl/hash/hash.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
 
 namespace grpc_core {
 

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

@@ -24,13 +24,13 @@
 #include <string>
 #include <utility>
 
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/resource_quota/thread_quota.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 

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

@@ -24,9 +24,9 @@
 #include <atomic>
 #include <new>
 
-#include "absl/log/log.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/util/alloc.h"
+#include "absl/log/log.h"
 namespace grpc_core {
 
 namespace {

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

@@ -102,6 +102,20 @@ template <typename T>
 const uint16_t ArenaContextTraits<T>::id_ =
     BaseArenaContextTraits::MakeId(DestroyArenaContext<T>);
 
+template <typename T, typename SfinaeVoid = void>
+struct GetContextId {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uint16_t id() {
+    return ArenaContextTraits<T>::id();
+  }
+};
+
+template <typename T>
+struct GetContextId<T, std::void_t<typename ContextSubclass<T>::Base>> {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uint16_t id() {
+    return GetContextId<typename ContextSubclass<T>::Base>::id();
+  }
+};
+
 template <typename T, typename A, typename B>
 struct IfArray {
   using Result = A;
@@ -292,8 +306,7 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   // often needs to access these directly.
   template <typename T>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T* GetContext() {
-    return static_cast<T*>(
-        contexts()[arena_detail::ArenaContextTraits<T>::id()]);
+    return static_cast<T*>(contexts()[arena_detail::GetContextId<T>::id()]);
   }
 
   template <typename T>

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

@@ -19,7 +19,7 @@
 #include <atomic>
 #include <cstdint>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -27,16 +27,17 @@ ConnectionQuota::ConnectionQuota() = default;
 
 void ConnectionQuota::SetMaxIncomingConnections(int max_incoming_connections) {
   // The maximum can only be configured once.
-  CHECK_LT(max_incoming_connections, INT_MAX);
-  CHECK(max_incoming_connections_.exchange(
-            max_incoming_connections, std::memory_order_release) == INT_MAX);
+  GRPC_CHECK_LT(max_incoming_connections, INT_MAX);
+  GRPC_CHECK(max_incoming_connections_.exchange(max_incoming_connections,
+                                                std::memory_order_release) ==
+             INT_MAX);
 }
 
 // Returns true if the incoming connection is allowed to be accepted on the
 // server.
 bool ConnectionQuota::AllowIncomingConnection(MemoryQuotaRefPtr mem_quota,
                                               absl::string_view /*peer*/) {
-  if (mem_quota->IsMemoryPressureHigh()) {
+  if (mem_quota->RejectNewConnectionsUnderHighMemoryPressure()) {
     return false;
   }
 
@@ -62,8 +63,9 @@ void ConnectionQuota::ReleaseConnections(int num_connections) {
   if (max_incoming_connections_.load(std::memory_order_relaxed) == INT_MAX) {
     return;
   }
-  CHECK(active_incoming_connections_.fetch_sub(
-            num_connections, std::memory_order_acq_rel) >= num_connections);
+  GRPC_CHECK(active_incoming_connections_.fetch_sub(
+                 num_connections, std::memory_order_acq_rel) >=
+             num_connections);
 }
 
 }  // namespace grpc_core

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

@@ -20,11 +20,11 @@
 #include <cstddef>
 #include <limits>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/lib/resource_quota/memory_quota.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_quota/memory_quota.cc

@@ -28,10 +28,6 @@
 #include <tuple>
 #include <utility>
 
-#include "absl/log/check.h"
-#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"
@@ -40,9 +36,14 @@
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/seq.h"
+#include "src/core/lib/resource_tracker/resource_tracker.h"
 #include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/mpscq.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -132,16 +133,20 @@ class SliceRefCount : public grpc_slice_refcount {
   size_t size_;
 };
 
-std::atomic<double> container_memory_pressure{0.0};
-
 }  // namespace
 
-void SetContainerMemoryPressure(double pressure) {
-  container_memory_pressure.store(pressure, std::memory_order_relaxed);
-}
-
 double ContainerMemoryPressure() {
-  return container_memory_pressure.load(std::memory_order_relaxed);
+  auto* tracker = ResourceTracker::Get();
+  if (tracker == nullptr) {
+    return 0.0;
+  }
+  auto value = tracker->GetMetricValue("memory");
+  if (!value.ok()) {
+    LOG(WARNING) << "Failed to get 'memory' metric from ResourceTracker: "
+                 << value.status();
+    return 0.0;
+  }
+  return *value;
 }
 
 //
@@ -272,9 +277,9 @@ GrpcMemoryAllocatorImpl::GrpcMemoryAllocatorImpl(
 }
 
 GrpcMemoryAllocatorImpl::~GrpcMemoryAllocatorImpl() {
-  CHECK_EQ(free_bytes_.load(std::memory_order_acquire) +
-               sizeof(GrpcMemoryAllocatorImpl),
-           taken_bytes_.load(std::memory_order_relaxed));
+  GRPC_CHECK_EQ(free_bytes_.load(std::memory_order_acquire) +
+                    sizeof(GrpcMemoryAllocatorImpl),
+                taken_bytes_.load(std::memory_order_relaxed));
   memory_quota_->Return(taken_bytes_.load(std::memory_order_relaxed));
 }
 
@@ -285,7 +290,7 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
       reclamation_handles[kNumReclamationPasses];
   {
     MutexLock lock(&reclaimer_mu_);
-    CHECK(!shutdown_);
+    GRPC_CHECK(!shutdown_);
     shutdown_ = true;
     memory_quota = memory_quota_;
     for (size_t i = 0; i < kNumReclamationPasses; i++) {
@@ -297,8 +302,8 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
 size_t GrpcMemoryAllocatorImpl::Reserve(MemoryRequest request) {
   // Validate request - performed here so we don't bloat the generated code with
   // inlined asserts.
-  CHECK(request.min() <= request.max());
-  CHECK(request.max() <= MemoryRequest::max_allowed_size());
+  GRPC_CHECK(request.min() <= request.max());
+  GRPC_CHECK(request.max() <= MemoryRequest::max_allowed_size());
   size_t old_free = free_bytes_.load(std::memory_order_relaxed);
 
   while (true) {
@@ -376,7 +381,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
                                           std::memory_order_acquire)) {
       GRPC_TRACE_LOG(resource_quota, INFO)
           << "[" << this << "] Early return " << ret << " bytes";
-      CHECK(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
+      GRPC_CHECK(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
       memory_quota_->Return(ret);
       return;
     }
@@ -448,11 +453,20 @@ class BasicMemoryQuota::WaitForSweepPromise {
 };
 
 BasicMemoryQuota::BasicMemoryQuota(
-    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
-    : channelz::DataSource(channelz_node) {
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node,
+    InstrumentStorageRefPtr<ResourceQuotaDomain> telemetry_storage)
+    : channelz::DataSource(channelz_node),
+      GaugeProvider(telemetry_storage),
+      telemetry_storage_(std::move(telemetry_storage)) {
+  ProviderConstructed();
   channelz::DataSource::SourceConstructed();
 }
 
+BasicMemoryQuota::~BasicMemoryQuota() {
+  ProviderDestructing();
+  channelz::DataSource::SourceDestructing();
+}
+
 void BasicMemoryQuota::Start() {
   auto self = shared_from_this();
 
@@ -518,7 +532,7 @@ void BasicMemoryQuota::Start() {
   reclaimer_activity_ =
       MakeActivity(std::move(reclamation_loop), ExecCtxWakeupScheduler(),
                    [](absl::Status status) {
-                     CHECK(status.code() == absl::StatusCode::kCancelled);
+                     GRPC_CHECK(status.code() == absl::StatusCode::kCancelled);
                    });
 }
 
@@ -538,7 +552,7 @@ void BasicMemoryQuota::SetSize(size_t new_size) {
 void BasicMemoryQuota::Take(GrpcMemoryAllocatorImpl* allocator, size_t amount) {
   // If there's a request for nothing, then do nothing!
   if (amount == 0) return;
-  DCHECK(amount <= std::numeric_limits<intptr_t>::max());
+  GRPC_DCHECK(amount <= std::numeric_limits<intptr_t>::max());
   // Grab memory from the quota.
   auto prior = free_bytes_.fetch_sub(amount, std::memory_order_acq_rel);
   // If we push into overcommit, awake the reclaimer.
@@ -698,12 +712,21 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   return pressure_info;
 }
 
+void BasicMemoryQuota::PopulateGaugeData(GaugeSink<ResourceQuotaDomain>& sink) {
+  auto pressure_info = GetPressureInfo();
+  sink.Set(ResourceQuotaDomain::kInstantaneousMemoryPressure,
+           pressure_info.instantaneous_pressure);
+  sink.Set(ResourceQuotaDomain::kMemoryPressureControlValue,
+           pressure_info.pressure_control_value);
+}
+
 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))
+          .Set("container_memory_pressure", ContainerMemoryPressure())
           .Merge(pressure_tracker_.ChannelzProperties())
           .Set("allocators",
                [this]() {
@@ -815,8 +838,6 @@ std::string PressureController::DebugString() const {
 }
 
 double PressureTracker::AddSampleAndGetControlValue(double sample) {
-  static const double kSetPoint = 0.95;
-
   double max_so_far = max_this_round_.load(std::memory_order_relaxed);
   if (sample > max_so_far) {
     max_this_round_.compare_exchange_weak(max_so_far, sample,
@@ -825,7 +846,7 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
   }
   // If memory pressure is almost done, immediately hit the brakes and report
   // full memory usage.
-  if (sample >= 0.99) {
+  if (sample >= memory_pressure_threshold_) {
     report_.store(1.0, std::memory_order_relaxed);
   }
   update_.Tick([&](Duration) {
@@ -833,11 +854,11 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
     const double current_estimate =
         max_this_round_.exchange(sample, std::memory_order_relaxed);
     double report;
-    if (current_estimate > 0.99) {
+    if (current_estimate > memory_pressure_threshold_) {
       // Under very high memory pressure we... just max things out.
       report = controller_.Update(1e99);
     } else {
-      report = controller_.Update(current_estimate - kSetPoint);
+      report = controller_.Update(current_estimate - target_memory_pressure_);
     }
     GRPC_TRACE_LOG(resource_quota, INFO)
         << "RQ: pressure:" << current_estimate << " report:" << report

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

@@ -15,8 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
 #define GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
 
+#include <grpc/event_engine/internal/memory_allocator_impl.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/memory_request.h>
+#include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
@@ -30,22 +32,25 @@
 #include <utility>
 #include <vector>
 
-#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/telemetry/instrument.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"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/log/log.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -134,7 +139,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 +278,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 +294,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 +309,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 +347,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 +405,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 +459,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 +481,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 +560,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 +594,10 @@ 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(GlobalCollectionScope(),
+                                            channelz_node->name()))) {
     memory_quota_->Start();
   }
   ~MemoryQuota() override {
@@ -579,9 +615,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 +635,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/periodic_update.h

@@ -20,8 +20,8 @@
 
 #include <atomic>
 
-#include "absl/functional/function_ref.h"
 #include "src/core/util/time.h"
+#include "absl/functional/function_ref.h"
 
 namespace grpc_core {
 

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

@@ -16,7 +16,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+#include <utility>
+
+#include "src/core/channelz/channelz.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/resource_quota/stream_quota.h"
+#include "src/core/lib/resource_quota/thread_quota.h"
 #include "src/core/util/no_destruct.h"
+#include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/single_set_ptr.h"
 
 namespace grpc_core {

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

@@ -22,14 +22,15 @@
 #include <string>
 #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/stream_quota.h"
 #include "src/core/lib/resource_quota/thread_quota.h"
 #include "src/core/util/cpp_impl_of.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -0,0 +1,22 @@
+// 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_quota/stream_quota.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <limits>
+
+namespace grpc_core {}  // namespace grpc_core

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

@@ -0,0 +1,31 @@
+// 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_STREAM_QUOTA_H
+#define GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_STREAM_QUOTA_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <cstdint>
+#include <limits>
+
+#include "src/core/lib/resource_quota/periodic_update.h"
+#include "src/core/util/per_cpu.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+
+namespace grpc_core {}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_STREAM_QUOTA_H

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

@@ -0,0 +1,55 @@
+// 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 absl::string_view kName = "resource_quota";
+  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