grpc 1.75.0 → 1.78.0

data/src/core/call/call_spine.h

@@ -17,11 +17,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/call/call_filters.h"
+#include "src/core/call/channelz_context.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -32,6 +33,7 @@
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -39,7 +41,7 @@ namespace grpc_core {
 // CallInitiator and CallHandler - which provide interfaces that are appropriate
 // for each side of a call.
 // Hosts context, call filters, and the arena.
-class CallSpine final : public Party {
+class CallSpine final : public Party, public channelz::DataSource {
  public:
   static RefCountedPtr<CallSpine> Create(
       ClientMetadataHandle client_initial_metadata,
@@ -49,7 +51,10 @@ class CallSpine final : public Party {
         std::move(client_initial_metadata), std::move(arena)));
   }
 
-  ~CallSpine() override { CallOnDone(true); }
+  ~CallSpine() override {
+    CallOnDone(true);
+    SourceDestructing();
+  }
 
   CallFilters& call_filters() { return call_filters_; }
 
@@ -132,7 +137,7 @@ class CallSpine final : public Party {
   // The resulting (returned) promise will resolve to Empty.
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
-    DCHECK(GetContext<Activity>() == this);
+    GRPC_DCHECK(GetContext<Activity>() == this);
     using P = promise_detail::PromiseLike<Promise>;
     using ResultType = typename P::Result;
     return Map(std::move(promise),
@@ -285,12 +290,29 @@ class CallSpine final : public Party {
     }
   }
 
+  void AddData(channelz::DataSink sink) override {
+    this->ExportToChannelz(
+        "call_spine", sink, [self = RefAsSubclass<CallSpine>()]() {
+          return channelz::PropertyList()
+              .Set("filters", self->call_filters_.ChannelzProperties())
+              .Set("child_calls", self->child_calls_.size())
+              .Set("has_on_done", self->on_done_ != nullptr);
+        });
+  }
+
  private:
   friend class Arena;
   CallSpine(ClientMetadataHandle client_initial_metadata,
-            RefCountedPtr<Arena> arena)
-      : Party(std::move(arena)),
-        call_filters_(std::move(client_initial_metadata)) {}
+            RefCountedPtr<Arena> a)
+      : Party(std::move(a)),
+        channelz::DataSource([this]() -> RefCountedPtr<channelz::BaseNode> {
+          auto* p = arena()->GetContext<channelz::CallNode>();
+          if (p == nullptr) return nullptr;
+          return p->Ref();
+        }()),
+        call_filters_(std::move(client_initial_metadata)) {
+    SourceConstructed();
+  }
 
   SpawnSerializer* client_to_server_serializer() {
     if (client_to_server_serializer_ == nullptr) {
@@ -324,7 +346,7 @@ class CallInitiator {
   CallInitiator() = default;
   explicit CallInitiator(RefCountedPtr<CallSpine> spine)
       : spine_(std::move(spine)) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
   }
 
   // Wrap a promise so that if it returns failure it automatically cancels
@@ -332,118 +354,118 @@ class CallInitiator {
   // The resulting (returned) promise will resolve to Empty.
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->CancelIfFails(std::move(promise));
   }
 
   auto PullServerInitialMetadata() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->PullServerInitialMetadata();
   }
 
   auto PushMessage(MessageHandle message) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->PushClientToServerMessage(std::move(message));
   }
 
   void SpawnPushMessage(MessageHandle message) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnPushClientToServerMessage(std::move(message));
   }
 
   void FinishSends() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->FinishSends();
   }
 
   void SpawnFinishSends() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnFinishSends();
   }
 
   auto PullMessage() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->PullServerToClientMessage();
   }
 
   auto PullServerTrailingMetadata() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->PullServerTrailingMetadata();
   }
 
   void Cancel(absl::Status error) {
-    DCHECK_NE(spine_.get(), nullptr);
-    CHECK(!error.ok());
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
+    GRPC_CHECK(!error.ok());
     auto status = ServerMetadataFromStatus(error);
     status->Set(GrpcCallWasCancelled(), true);
     spine_->PushServerTrailingMetadata(std::move(status));
   }
 
   void SpawnCancel(absl::Status error) {
-    DCHECK_NE(spine_.get(), nullptr);
-    CHECK(!error.ok());
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
+    GRPC_CHECK(!error.ok());
     auto status = ServerMetadataFromStatus(error);
     status->Set(GrpcCallWasCancelled(), true);
     spine_->SpawnPushServerTrailingMetadata(std::move(status));
   }
 
   void Cancel() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->Cancel();
   }
 
   void SpawnCancel() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnCancel();
   }
 
   GRPC_MUST_USE_RESULT bool OnDone(absl::AnyInvocable<void(bool)> fn) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->OnDone(std::move(fn));
   }
 
   template <typename Promise>
   auto UntilCallCompletes(Promise promise) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->UntilCallCompletes(std::move(promise));
   }
 
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnGuarded(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   void SpawnGuardedUntilCallCompletes(absl::string_view name,
                                       PromiseFactory promise_factory) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnGuardedUntilCallCompletes(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnInfallible(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->SpawnWaitable(name, std::move(promise_factory));
   }
 
   bool WasCancelledPushed() const {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->call_filters().WasCancelledPushed();
   }
 
   Arena* arena() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_->arena();
   }
   Party* party() {
-    DCHECK_NE(spine_.get(), nullptr);
+    GRPC_DCHECK_NE(spine_.get(), nullptr);
     return spine_.get();
   }
 
@@ -535,7 +557,7 @@ class CallHandler {
   }
 
   void AddChildCall(const CallInitiator& initiator) {
-    CHECK(initiator.spine_ != nullptr);
+    GRPC_CHECK(initiator.spine_ != nullptr);
     spine_->AddChildCall(initiator.spine_);
   }
 

data/src/core/call/channelz_context.h

@@ -0,0 +1,30 @@
+// 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_CALL_CHANNELZ_CONTEXT_H
+#define GRPC_SRC_CORE_CALL_CHANNELZ_CONTEXT_H
+
+#include "src/core/channelz/channelz.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+template <>
+struct ArenaContextType<channelz::CallNode> {
+  static void Destroy(channelz::CallNode*) {}
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CALL_CHANNELZ_CONTEXT_H

data/src/core/call/client_call.cc

@@ -39,9 +39,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/all_ok.h"
@@ -54,9 +51,12 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -105,7 +105,7 @@ ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
                        grpc_compression_options compression_options,
                        RefCountedPtr<Arena> arena,
                        RefCountedPtr<UnstartedCallDestination> destination)
-    : Call(false, deadline, std::move(arena)),
+    : Call(/*is_client=*/true, deadline, std::move(arena)),
       DualRefCounted("ClientCall"),
       cq_(cq),
       call_destination_(std::move(destination)),
@@ -120,8 +120,37 @@ ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
       reinterpret_cast<void*>(static_cast<uintptr_t>(registered_method)));
   if (deadline != Timestamp::InfFuture()) {
     send_initial_metadata_->Set(GrpcTimeoutMetadata(), deadline);
-    UpdateDeadline(deadline);
+    UpdateDeadline(deadline).IgnoreError();
   }
+  SourceConstructed();
+}
+
+void ClientCall::AddData(channelz::DataSink sink) {
+  Call::AddData(sink);
+  sink.AddData(
+      "client_call",
+      channelz::PropertyList()
+          .Set("call_state",
+               [this]() {
+                 switch (call_state_.load(std::memory_order_relaxed)) {
+                   case kUnstarted:
+                     return "Unstarted";
+                   case kStarted:
+                     return "Started";
+                   case kCancelled:
+                     return "Cancelled";
+                   default:
+                     return "StartedWithoutInitialMetadata";
+                 }
+               }())
+          .Set("cancel_status",
+               [this]() -> std::string {
+                 auto* p = cancel_status_.Get();
+                 if (p == nullptr) return "not cancelled";
+                 return p->ToString();
+               }())
+          .Set("saw_trailing_metadata",
+               saw_trailing_metadata_.load(std::memory_order_relaxed)));
 }
 
 grpc_call_error ClientCall::StartBatch(const grpc_op* ops, size_t nops,
@@ -228,11 +257,20 @@ Party::WakeupHold ClientCall::StartCall(
     const grpc_op& send_initial_metadata_op) {
   GRPC_LATENT_SEE_SCOPE("ClientCall::StartCall");
   auto cur_state = call_state_.load(std::memory_order_acquire);
+  // TODO(akshitpatel): [PH2][P3]: Might need to invoke
+  // PrepareApplicationMetadata here.
   CToMetadata(send_initial_metadata_op.data.send_initial_metadata.metadata,
               send_initial_metadata_op.data.send_initial_metadata.count,
               send_initial_metadata_.get());
   PrepareOutgoingInitialMetadata(send_initial_metadata_op,
                                  *send_initial_metadata_);
+  send_initial_metadata_->Set(
+      WaitForReady(),
+      WaitForReady::ValueType{
+          (send_initial_metadata_op.flags &
+           GRPC_INITIAL_METADATA_WAIT_FOR_READY) != 0,
+          (send_initial_metadata_op.flags &
+           GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET) != 0});
   auto call = MakeCallPair(std::move(send_initial_metadata_), arena()->Ref());
   started_call_initiator_ = std::move(call.initiator);
   Party::WakeupHold wakeup_hold{started_call_initiator_.party()};
@@ -264,7 +302,7 @@ bool ClientCall::StartCallMaybeUpdateState(uintptr_t& cur_state,
                                               std::memory_order_acquire)) {
         call_destination_->StartCall(std::move(handler));
         auto unordered_start = reinterpret_cast<UnorderedStart*>(cur_state);
-        while (unordered_start->next != nullptr) {
+        while (unordered_start != nullptr) {
           unordered_start->start_pending_batch();
           auto next = unordered_start->next;
           delete unordered_start;
@@ -376,7 +414,7 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
             [this, out_status, out_status_details, out_error_string,
              out_trailing_metadata]() {
               auto* status = cancel_status_.Get();
-              CHECK_NE(status, nullptr);
+              GRPC_CHECK_NE(status, nullptr);
               *out_status = static_cast<grpc_status_code>(status->code());
               *out_status_details =
                   Slice::FromCopiedString(status->message()).TakeCSlice();
@@ -445,9 +483,10 @@ grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,
                           RefCountedPtr<UnstartedCallDestination> destination) {
-  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);
   return arena
       ->New<ClientCall>(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), registered_method, deadline,

data/src/core/call/client_call.h

@@ -37,9 +37,6 @@
 #include <cstdint>
 #include <string>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -49,6 +46,9 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/single_set_ptr.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -78,6 +78,7 @@ class ClientCall final
   void InternalUnref(const char*) override { WeakUnref(); }
 
   void Orphaned() override {
+    SourceDestructing();
     if (!saw_trailing_metadata_.load(std::memory_order_relaxed)) {
       CancelWithError(absl::CancelledError());
     }
@@ -118,6 +119,8 @@ class ClientCall final
     this->~ClientCall();
   }
 
+  void AddData(channelz::DataSink sink) override;
+
  private:
   struct UnorderedStart {
     absl::AnyInvocable<void()> start_pending_batch;

data/src/core/call/filter_fusion.h

@@ -23,11 +23,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_join.h"
 #include "src/core/call/call_filters.h"
 #include "src/core/call/metadata.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -35,9 +30,14 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/type_list.h"
+#include "absl/log/log.h"
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_join.h"
 
 struct grpc_transport_op;
 
@@ -1021,14 +1021,14 @@ struct FilterWrapper<Typelist<Filter>> {
 
   absl::Status status() const { return filter_.status(); }
   bool StartTransportOp(grpc_transport_op* op) {
-    CHECK(filter_.ok());
+    GRPC_CHECK(filter_.ok());
     return (*filter_)->StartTransportOp(op);
   }
 
   Filter* get_filter() { return (*filter_).get(); }
 
   bool GetChannelInfo(const grpc_channel_info* info) {
-    CHECK(filter_.ok());
+    GRPC_CHECK(filter_.ok());
     return (*filter_)->GetChannelInfo(info);
   }
 
@@ -1053,13 +1053,13 @@ struct FilterWrapper<Typelist<Filter0, Filters...>>
   Filter0* get_filter() { return (*filter0_).get(); }
 
   bool StartTransportOp(grpc_transport_op* op) {
-    CHECK(filter0_.ok());
+    GRPC_CHECK(filter0_.ok());
     return (*filter0_)->StartTransportOp(op) ||
            FilterWrapper<Typelist<Filters...>>::StartTransportOp(op);
   }
 
   bool GetChannelInfo(const grpc_channel_info* info) {
-    CHECK(filter0_.ok());
+    GRPC_CHECK(filter0_.ok());
     return (*filter0_)->GetChannelInfo(info) ||
            FilterWrapper<Typelist<Filters...>>::GetChannelInfo(info);
   }

data/src/core/call/interception_chain.h

@@ -24,6 +24,7 @@
 #include "src/core/call/call_filters.h"
 #include "src/core/call/call_spine.h"
 #include "src/core/call/metadata.h"
+#include "src/core/filter/filter_args.h"
 #include "src/core/util/ref_counted.h"
 
 namespace grpc_core {
@@ -171,10 +172,10 @@ class InterceptionChainBuilder final {
   // call_filters.h.
   template <typename T>
   absl::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
-  Add() {
+  Add(RefCountedPtr<const FilterConfig> config) {
     if (!status_.ok()) return *this;
-    auto filter =
-        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_});
+    auto filter = T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
+                                    std::move(config), blackboard_});
     if (!filter.ok()) {
       status_ = filter.status();
       return *this;
@@ -189,9 +190,9 @@ class InterceptionChainBuilder final {
   template <typename T>
   absl::enable_if_t<std::is_base_of<Interceptor, T>::value,
                     InterceptionChainBuilder&>
-  Add() {
-    AddInterceptor(
-        T::Create(args_, {FilterInstanceId(FilterTypeId<T>()), blackboard_}));
+  Add(RefCountedPtr<const FilterConfig> config) {
+    AddInterceptor(T::Create(args_, {FilterInstanceId(FilterTypeId<T>()),
+                                     std::move(config), blackboard_}));
     return *this;
   };
 

data/src/core/call/metadata_batch.cc

@@ -20,15 +20,60 @@
 #include <algorithm>
 #include <string>
 
-#include "absl/base/no_destructor.h"
-#include "absl/container/flat_hash_set.h"
+#include "src/core/lib/transport/timeout_encoding.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "src/core/lib/transport/timeout_encoding.h"
 
 namespace grpc_core {
+
+bool IsMetadataKeyAllowedInDebugOutput(absl::string_view key) {
+  // We have intentionally not allowed for any way to add to the allow list at
+  // run time, (using a flag or some other setting) because such workarounds
+  // may lead to security issues.
+  // go/keep-sorted start
+  if (key == ContentTypeMetadata::key()) return true;
+  if (key == EndpointLoadMetricsBinMetadata::key()) return true;
+  if (key == GrpcAcceptEncodingMetadata::key()) return true;
+  if (key == GrpcEncodingMetadata::key()) return true;
+  if (key == GrpcInternalEncodingRequest::key()) return true;
+  if (key == GrpcLbClientStatsMetadata::key()) return true;
+  if (key == GrpcMessageMetadata::key()) return true;
+  if (key == GrpcPreviousRpcAttemptsMetadata::key()) return true;
+  if (key == GrpcRetryPushbackMsMetadata::key()) return true;
+  if (key == GrpcServerStatsBinMetadata::key()) return true;
+  if (key == GrpcStatusMetadata::key()) return true;
+  if (key == GrpcTagsBinMetadata::key()) return true;
+  if (key == GrpcTimeoutMetadata::key()) return true;
+  if (key == GrpcTraceBinMetadata::key()) return true;
+  if (key == HostMetadata::key()) return true;
+  if (key == HttpAuthorityMetadata::key()) return true;
+  if (key == HttpMethodMetadata::key()) return true;
+  if (key == HttpPathMetadata::key()) return true;
+  if (key == HttpSchemeMetadata::key()) return true;
+  if (key == HttpStatusMetadata::key()) return true;
+  if (key == LbCostBinMetadata::key()) return true;
+  if (key == LbTokenMetadata::key()) return true;
+  if (key == TeMetadata::key()) return true;
+  if (key == UserAgentMetadata::key()) return true;
+  if (key == W3CTraceParentMetadata::key()) return true;
+  if (key == XEnvoyPeerMetadata::key()) return true;
+  // go/keep-sorted end
+  // go/keep-sorted start
+  if (key == GrpcCallWasCancelled::DebugKey()) return true;
+  if (key == GrpcRegisteredMethod::DebugKey()) return true;
+  if (key == GrpcStatusContext::DebugKey()) return true;
+  if (key == GrpcStatusFromWire::DebugKey()) return true;
+  if (key == GrpcStreamNetworkState::DebugKey()) return true;
+  if (key == GrpcTarPit::DebugKey()) return true;
+  if (key == GrpcTrailersOnly::DebugKey()) return true;
+  if (key == PeerString::DebugKey()) return true;
+  if (key == WaitForReady::DebugKey()) return true;
+  // go/keep-sorted end
+  return false;
+}
+
 namespace metadata_detail {
 
 void DebugStringBuilder::Add(absl::string_view key, absl::string_view value) {
@@ -38,7 +83,7 @@ void DebugStringBuilder::Add(absl::string_view key, absl::string_view value) {
 
 void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
                                            absl::string_view value) {
-  if (IsAllowListed(key)) {
+  if (IsMetadataKeyAllowedInDebugOutput(key)) {
     Add(key, value);
   } else {
     // If the type of metadata is not in the allow list, we want to prevent it
@@ -51,57 +96,6 @@ void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
   }
 }
 
-bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
-  // We have intentionally not allowed for any way to add to the allow list at
-  // run time, (using a flag or some other setting) because such workarounds
-  // may lead to security issues.
-  static const absl::NoDestructor<absl::flat_hash_set<std::string>> allow_list(
-      [] {
-        absl::flat_hash_set<std::string> allow_list;
-        // go/keep-sorted start
-        allow_list.insert(std::string(ContentTypeMetadata::key()));
-        allow_list.insert(std::string(EndpointLoadMetricsBinMetadata::key()));
-        allow_list.insert(std::string(GrpcAcceptEncodingMetadata::key()));
-        allow_list.insert(std::string(GrpcEncodingMetadata::key()));
-        allow_list.insert(std::string(GrpcInternalEncodingRequest::key()));
-        allow_list.insert(std::string(GrpcLbClientStatsMetadata::key()));
-        allow_list.insert(std::string(GrpcMessageMetadata::key()));
-        allow_list.insert(std::string(GrpcPreviousRpcAttemptsMetadata::key()));
-        allow_list.insert(std::string(GrpcRetryPushbackMsMetadata::key()));
-        allow_list.insert(std::string(GrpcServerStatsBinMetadata::key()));
-        allow_list.insert(std::string(GrpcStatusMetadata::key()));
-        allow_list.insert(std::string(GrpcTagsBinMetadata::key()));
-        allow_list.insert(std::string(GrpcTimeoutMetadata::key()));
-        allow_list.insert(std::string(GrpcTraceBinMetadata::key()));
-        allow_list.insert(std::string(HostMetadata::key()));
-        allow_list.insert(std::string(HttpAuthorityMetadata::key()));
-        allow_list.insert(std::string(HttpMethodMetadata::key()));
-        allow_list.insert(std::string(HttpPathMetadata::key()));
-        allow_list.insert(std::string(HttpSchemeMetadata::key()));
-        allow_list.insert(std::string(HttpStatusMetadata::key()));
-        allow_list.insert(std::string(LbCostBinMetadata::key()));
-        allow_list.insert(std::string(LbTokenMetadata::key()));
-        allow_list.insert(std::string(TeMetadata::key()));
-        allow_list.insert(std::string(UserAgentMetadata::key()));
-        allow_list.insert(std::string(W3CTraceParentMetadata::key()));
-        allow_list.insert(std::string(XEnvoyPeerMetadata::key()));
-        // go/keep-sorted end
-        // go/keep-sorted start
-        allow_list.insert(std::string(GrpcCallWasCancelled::DebugKey()));
-        allow_list.insert(std::string(GrpcRegisteredMethod::DebugKey()));
-        allow_list.insert(std::string(GrpcStatusContext::DebugKey()));
-        allow_list.insert(std::string(GrpcStatusFromWire::DebugKey()));
-        allow_list.insert(std::string(GrpcStreamNetworkState::DebugKey()));
-        allow_list.insert(std::string(GrpcTarPit::DebugKey()));
-        allow_list.insert(std::string(GrpcTrailersOnly::DebugKey()));
-        allow_list.insert(std::string(PeerString::DebugKey()));
-        allow_list.insert(std::string(WaitForReady::DebugKey()));
-        // go/keep-sorted end
-        return allow_list;
-      }());
-  return allow_list->contains(key);
-}
-
 void UnknownMap::Append(absl::string_view key, Slice value) {
   unknown_.emplace_back(Slice::FromCopiedString(key), value.Ref());
 }