grpc 1.62.0 → 1.68.1

data/src/core/lib/transport/metadata.cc

@@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/transport/metadata.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
-ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
-                                              Arena* arena) {
-  auto hdl = arena->MakePooled<ServerMetadata>(arena);
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
   grpc_status_code code;
   std::string message;
   grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,
@@ -34,4 +34,28 @@ ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
   return hdl;
 }
 
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    const absl::Status& status) {
+  auto hdl = ServerMetadataFromStatus(status);
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+
+ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code,
+                                              absl::string_view message) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  return hdl;
+}
+
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code, absl::string_view message) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+
 }  // namespace grpc_core

data/src/core/lib/transport/metadata.h

@@ -31,6 +31,19 @@ using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
 using ClientMetadata = grpc_metadata_batch;
 using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
 
+// TODO(ctiller): separate when we have different types for client/server
+// metadata.
+template <typename Sink>
+void AbslStringify(Sink& sink, const Arena::PoolPtr<grpc_metadata_batch>& md) {
+  if (md == nullptr) {
+    sink.Append("nullptr");
+    return;
+  }
+  sink.Append("ServerMetadata{");
+  sink.Append(md->DebugString());
+  sink.Append("}");
+}
+
 // Ok/not-ok check for trailing metadata, so that it can be used as result types
 // for TrySeq.
 inline bool IsStatusOk(const ServerMetadataHandle& m) {
@@ -38,8 +51,30 @@ inline bool IsStatusOk(const ServerMetadataHandle& m) {
          GRPC_STATUS_OK;
 }
 
-ServerMetadataHandle ServerMetadataFromStatus(
-    const absl::Status& status, Arena* arena = GetContext<Arena>());
+// Convert absl::Status to ServerMetadata
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status);
+// Convert absl::Status to ServerMetadata, and set GrpcCallWasCancelled() to
+// true
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    const absl::Status& status);
+// Server metadata with status code set
+inline ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  return hdl;
+}
+inline ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+// The same, but with an error string
+ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code,
+                                              absl::string_view message);
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code, absl::string_view message);
 
 template <>
 struct StatusCastImpl<ServerMetadataHandle, absl::Status> {

data/src/core/lib/transport/metadata_batch.cc

@@ -12,19 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/transport/metadata_batch.h"
 
+#include <grpc/support/port_platform.h>
 #include <string.h>
 
 #include <algorithm>
+#include <string>
 
+#include "absl/base/no_destructor.h"
+#include "absl/container/flat_hash_set.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 {
@@ -35,15 +36,73 @@ void DebugStringBuilder::Add(absl::string_view key, absl::string_view value) {
   absl::StrAppend(&out_, absl::CEscape(key), ": ", absl::CEscape(value));
 }
 
+void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
+                                           absl::string_view value) {
+  if (IsAllowListed(key)) {
+    Add(key, value);
+  } else {
+    Add(key, absl::StrCat(value.size(), " bytes redacted by allow listing."));
+  }
+}
+
+bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
+  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(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_.EmplaceBack(Slice::FromCopiedString(key), value.Ref());
+  unknown_.emplace_back(Slice::FromCopiedString(key), value.Ref());
 }
 
 void UnknownMap::Remove(absl::string_view key) {
-  unknown_.SetEnd(std::remove_if(unknown_.begin(), unknown_.end(),
-                                 [key](const std::pair<Slice, Slice>& p) {
-                                   return p.first.as_string_view() == key;
-                                 }));
+  unknown_.erase(std::remove_if(unknown_.begin(), unknown_.end(),
+                                [key](const std::pair<Slice, Slice>& p) {
+                                  return p.first.as_string_view() == key;
+                                }),
+                 unknown_.end());
 }
 
 absl::optional<absl::string_view> UnknownMap::GetStringValue(

data/src/core/lib/transport/metadata_batch.h

@@ -19,8 +19,9 @@
 #ifndef GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_BATCH_H
 #define GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_BATCH_H
 
+#include <grpc/impl/compression_types.h>
+#include <grpc/status.h>
 #include <grpc/support/port_platform.h>
-
 #include <stdlib.h>
 
 #include <cstdint>
@@ -30,29 +31,24 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/function_ref.h"
+#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-
-#include <grpc/impl/compression_types.h>
-#include <grpc/status.h>
-#include <grpc/support/log.h>
-
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/gprpp/chunked_vector.h"
-#include "src/core/lib/gprpp/if_list.h"
-#include "src/core/lib/gprpp/packed_table.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/gprpp/type_list.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/custom_metadata.h"
 #include "src/core/lib/transport/metadata_compression_traits.h"
 #include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/lib/transport/simple_slice_based_metadata.h"
+#include "src/core/util/chunked_vector.h"
+#include "src/core/util/if_list.h"
+#include "src/core/util/packed_table.h"
+#include "src/core/util/time.h"
+#include "src/core/util/type_list.h"
 
 namespace grpc_core {
 
@@ -78,6 +74,7 @@ size_t EncodedSizeOfKey(Key, const typename Key::ValueType& value) {
 // should not need to.
 struct GrpcTimeoutMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using ValueType = Timestamp;
   using MementoType = Duration;
   using CompressionTraits = TimeoutCompressor;
@@ -94,6 +91,7 @@ struct GrpcTimeoutMetadata {
 // TE metadata trait.
 struct TeMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   // HTTP2 says that TE can either be empty or "trailers".
   // Empty means this trait is not included, "trailers" means kTrailers, and
   // kInvalid is used to remember an invalid value.
@@ -109,7 +107,7 @@ struct TeMetadata {
                                   MetadataParseErrorFn on_error);
   static ValueType MementoToValue(MementoType te) { return te; }
   static StaticSlice Encode(ValueType x) {
-    GPR_ASSERT(x == kTrailers);
+    CHECK(x == kTrailers);
     return StaticSlice::FromStaticString("trailers");
   }
   static const char* DisplayValue(ValueType te);
@@ -123,6 +121,7 @@ inline size_t EncodedSizeOfKey(TeMetadata, TeMetadata::ValueType x) {
 // content-type metadata trait.
 struct ContentTypeMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = true;
   // gRPC says that content-type can be application/grpc[;something]
   // Core has only ever verified the prefix.
   // IF we want to start verifying more, we can expand this type.
@@ -151,6 +150,7 @@ struct ContentTypeMetadata {
 // scheme metadata trait.
 struct HttpSchemeMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   enum ValueType : uint8_t {
     kHttp,
     kHttps,
@@ -180,6 +180,7 @@ size_t EncodedSizeOfKey(HttpSchemeMetadata, HttpSchemeMetadata::ValueType x);
 // method metadata trait.
 struct HttpMethodMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   enum ValueType : uint8_t {
     kPost,
     kGet,
@@ -212,7 +213,7 @@ struct CompressionAlgorithmBasedMetadata {
                                   MetadataParseErrorFn on_error);
   static ValueType MementoToValue(MementoType x) { return x; }
   static Slice Encode(ValueType x) {
-    GPR_ASSERT(x != GRPC_COMPRESS_ALGORITHMS_COUNT);
+    CHECK(x != GRPC_COMPRESS_ALGORITHMS_COUNT);
     return Slice::FromStaticString(CompressionAlgorithmAsString(x));
   }
   static const char* DisplayValue(ValueType x) {
@@ -228,6 +229,7 @@ struct CompressionAlgorithmBasedMetadata {
 // grpc-encoding metadata trait.
 struct GrpcEncodingMetadata : public CompressionAlgorithmBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits =
       SmallIntegralValuesCompressor<GRPC_COMPRESS_ALGORITHMS_COUNT>;
   static absl::string_view key() { return "grpc-encoding"; }
@@ -236,6 +238,7 @@ struct GrpcEncodingMetadata : public CompressionAlgorithmBasedMetadata {
 // grpc-internal-encoding-request metadata trait.
 struct GrpcInternalEncodingRequest : public CompressionAlgorithmBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "grpc-internal-encoding-request"; }
 };
@@ -243,6 +246,7 @@ struct GrpcInternalEncodingRequest : public CompressionAlgorithmBasedMetadata {
 // grpc-accept-encoding metadata trait.
 struct GrpcAcceptEncodingMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   static absl::string_view key() { return "grpc-accept-encoding"; }
   using ValueType = CompressionAlgorithmSet;
   using MementoType = ValueType;
@@ -261,6 +265,7 @@ struct GrpcAcceptEncodingMetadata {
 // user-agent metadata trait.
 struct UserAgentMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = StableValueCompressor;
   static absl::string_view key() { return "user-agent"; }
 };
@@ -268,6 +273,7 @@ struct UserAgentMetadata : public SimpleSliceBasedMetadata {
 // grpc-message metadata trait.
 struct GrpcMessageMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "grpc-message"; }
 };
@@ -275,6 +281,7 @@ struct GrpcMessageMetadata : public SimpleSliceBasedMetadata {
 // host metadata trait.
 struct HostMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "host"; }
 };
@@ -282,6 +289,7 @@ struct HostMetadata : public SimpleSliceBasedMetadata {
 // endpoint-load-metrics-bin metadata trait.
 struct EndpointLoadMetricsBinMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "endpoint-load-metrics-bin"; }
 };
@@ -289,6 +297,7 @@ struct EndpointLoadMetricsBinMetadata : public SimpleSliceBasedMetadata {
 // grpc-server-stats-bin metadata trait.
 struct GrpcServerStatsBinMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "grpc-server-stats-bin"; }
 };
@@ -296,6 +305,7 @@ struct GrpcServerStatsBinMetadata : public SimpleSliceBasedMetadata {
 // grpc-trace-bin metadata trait.
 struct GrpcTraceBinMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = FrequentKeyWithNoValueCompressionCompressor;
   static absl::string_view key() { return "grpc-trace-bin"; }
 };
@@ -303,6 +313,7 @@ struct GrpcTraceBinMetadata : public SimpleSliceBasedMetadata {
 // grpc-tags-bin metadata trait.
 struct GrpcTagsBinMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = FrequentKeyWithNoValueCompressionCompressor;
   static absl::string_view key() { return "grpc-tags-bin"; }
 };
@@ -310,6 +321,7 @@ struct GrpcTagsBinMetadata : public SimpleSliceBasedMetadata {
 // XEnvoyPeerMetadata
 struct XEnvoyPeerMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = true;
   using CompressionTraits = StableValueCompressor;
   static absl::string_view key() { return "x-envoy-peer-metadata"; }
 };
@@ -317,6 +329,7 @@ struct XEnvoyPeerMetadata : public SimpleSliceBasedMetadata {
 // :authority metadata trait.
 struct HttpAuthorityMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = SmallSetOfValuesCompressor;
   static absl::string_view key() { return ":authority"; }
 };
@@ -324,6 +337,7 @@ struct HttpAuthorityMetadata : public SimpleSliceBasedMetadata {
 // :path metadata trait.
 struct HttpPathMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = SmallSetOfValuesCompressor;
   static absl::string_view key() { return ":path"; }
 };
@@ -358,6 +372,7 @@ struct SimpleIntBasedMetadata : public SimpleIntBasedMetadataBase<Int> {
 struct GrpcStatusMetadata
     : public SimpleIntBasedMetadata<grpc_status_code, GRPC_STATUS_UNKNOWN> {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = SmallIntegralValuesCompressor<16>;
   static absl::string_view key() { return "grpc-status"; }
 };
@@ -366,6 +381,7 @@ struct GrpcStatusMetadata
 struct GrpcPreviousRpcAttemptsMetadata
     : public SimpleIntBasedMetadata<uint32_t, 0> {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "grpc-previous-rpc-attempts"; }
 };
@@ -373,6 +389,7 @@ struct GrpcPreviousRpcAttemptsMetadata
 // grpc-retry-pushback-ms metadata trait.
 struct GrpcRetryPushbackMsMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   static absl::string_view key() { return "grpc-retry-pushback-ms"; }
   using ValueType = Duration;
   using MementoType = Duration;
@@ -390,6 +407,7 @@ struct GrpcRetryPushbackMsMetadata {
 // TODO(ctiller): consider moving to uint16_t
 struct HttpStatusMetadata : public SimpleIntBasedMetadata<uint32_t, 0> {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = true;
   using CompressionTraits = HttpStatusCompressor;
   static absl::string_view key() { return ":status"; }
 };
@@ -400,6 +418,7 @@ class GrpcLbClientStats;
 
 struct GrpcLbClientStatsMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   static absl::string_view key() { return "grpclb_client_stats"; }
   using ValueType = GrpcLbClientStats*;
   using MementoType = ValueType;
@@ -424,6 +443,7 @@ inline size_t EncodedSizeOfKey(GrpcLbClientStatsMetadata,
 // lb-token metadata
 struct LbTokenMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   using CompressionTraits = NoCompressionCompressor;
   static absl::string_view key() { return "lb-token"; }
 };
@@ -431,6 +451,7 @@ struct LbTokenMetadata : public SimpleSliceBasedMetadata {
 // lb-cost-bin metadata
 struct LbCostBinMetadata {
   static constexpr bool kRepeatable = true;
+  static constexpr bool kTransferOnTrailersOnly = false;
   static absl::string_view key() { return "lb-cost-bin"; }
   struct ValueType {
     double cost;
@@ -452,6 +473,7 @@ struct LbCostBinMetadata {
 struct GrpcStreamNetworkState {
   static absl::string_view DebugKey() { return "GrpcStreamNetworkState"; }
   static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
   enum ValueType : uint8_t {
     kNotSentOnWire,
     kNotSeenByServer,
@@ -503,6 +525,14 @@ struct WaitForReady {
   static std::string DisplayValue(ValueType x);
 };
 
+// Annotation added by retry code to indicate a transparent retry.
+struct IsTransparentRetry {
+  static absl::string_view DebugKey() { return "IsTransparentRetry"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = bool;
+  static std::string DisplayValue(ValueType x) { return x ? "true" : "false"; }
+};
+
 // Annotation added by a transport to note that server trailing metadata
 // is a Trailers-Only response.
 struct GrpcTrailersOnly {
@@ -538,14 +568,17 @@ namespace metadata_detail {
 // The string is expected to be readable, but not necessarily parsable.
 class DebugStringBuilder {
  public:
-  // Add one key/value pair to the output.
-  void Add(absl::string_view key, absl::string_view value);
+  // Add one key/value pair to the output if it is allow listed.
+  // Redact only the value if it is not allow listed.
+  void AddAfterRedaction(absl::string_view key, absl::string_view value);
 
   // Finalize the output and return the string.
   // Subsequent Add calls are UB.
   std::string TakeOutput() { return std::move(out_); }
 
  private:
+  bool IsAllowListed(absl::string_view key) const;
+  void Add(absl::string_view key, absl::string_view value);
   std::string out_;
 };
 
@@ -1016,6 +1049,26 @@ struct LogWrapper {
   }
 };
 
+// Callable for the table FilterIn -- for each value, call the
+// appropriate filter method to determine of the value should be kept or
+// removed.
+template <typename Filterer>
+struct FilterWrapper {
+  Filterer filter_fn;
+
+  template <typename Which,
+            absl::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
+  bool operator()(const Value<Which>& /*which*/) {
+    return filter_fn(Which());
+  }
+
+  template <typename Which,
+            absl::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
+  bool operator()(const Value<Which>& /*which*/) {
+    return true;
+  }
+};
+
 // Encoder to compute TransportSize
 class TransportSizeEncoder {
  public:
@@ -1048,22 +1101,29 @@ class TransportSizeEncoder {
 // Handle unknown (non-trait-based) fields in the metadata map.
 class UnknownMap {
  public:
-  explicit UnknownMap(Arena* arena) : unknown_(arena) {}
-
-  using BackingType = ChunkedVector<std::pair<Slice, Slice>, 5>;
+  using BackingType = std::vector<std::pair<Slice, Slice>>;
 
   void Append(absl::string_view key, Slice value);
   void Remove(absl::string_view key);
   absl::optional<absl::string_view> GetStringValue(absl::string_view key,
                                                    std::string* backing) const;
 
-  BackingType::ConstForwardIterator begin() const { return unknown_.cbegin(); }
-  BackingType::ConstForwardIterator end() const { return unknown_.cend(); }
+  BackingType::const_iterator begin() const { return unknown_.cbegin(); }
+  BackingType::const_iterator end() const { return unknown_.cend(); }
+
+  template <typename Filterer>
+  void Filter(Filterer* filter_fn) {
+    unknown_.erase(
+        std::remove_if(unknown_.begin(), unknown_.end(),
+                       [&](auto& pair) {
+                         return !(*filter_fn)(pair.first.as_string_view());
+                       }),
+        unknown_.end());
+  }
 
   bool empty() const { return unknown_.empty(); }
   size_t size() const { return unknown_.size(); }
-  void Clear() { unknown_.Clear(); }
-  Arena* arena() const { return unknown_.arena(); }
+  void Clear() { unknown_.clear(); }
 
  private:
   // Backing store for added metadata.
@@ -1150,6 +1210,9 @@ MetadataValueAsSlice(typename Which::ValueType value) {
 // struct GrpcXyzMetadata {
 //   // Can this metadata field be repeated?
 //   static constexpr bool kRepeatable = ...;
+//   // Should this metadata be transferred from server headers to trailers on
+//   // Trailers-Only response?
+//   static constexpr bool kTransferOnTrailersOnly = ...;
 //   // The type that's stored on MetadataBatch
 //   using ValueType = ...;
 //   // The type that's stored in compression/decompression tables
@@ -1220,7 +1283,7 @@ MetadataValueAsSlice(typename Which::ValueType value) {
 template <class Derived, typename... Traits>
 class MetadataMap {
  public:
-  explicit MetadataMap(Arena* arena);
+  MetadataMap() = default;
   ~MetadataMap();
 
   // Given a compressor factory - template taking <MetadataTrait,
@@ -1278,14 +1341,30 @@ class MetadataMap {
     }
   }
 
+  // Filter the metadata map.
+  // Iterates over all encodable and unknown headers and calls the filter_fn
+  // for each of them. If the function returns true, the header is kept.
+  template <typename Filterer>
+  void Filter(Filterer filter_fn) {
+    table_.template FilterIn<metadata_detail::FilterWrapper<Filterer>,
+                             Value<Traits>...>(
+        metadata_detail::FilterWrapper<Filterer>{filter_fn});
+    unknown_.Filter<Filterer>(&filter_fn);
+  }
+
   std::string DebugString() const {
     metadata_detail::DebugStringBuilder builder;
     Log([&builder](absl::string_view key, absl::string_view value) {
-      builder.Add(key, value);
+      builder.AddAfterRedaction(key, value);
     });
     return builder.TakeOutput();
   }
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const MetadataMap& map) {
+    sink.Append(map.DebugString());
+  }
+
   // Get the pointer to the value of some known metadata.
   // Returns nullptr if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.
@@ -1443,9 +1522,6 @@ inline bool IsStatusOk(const MetadataMap<Derived, Args...>& m) {
          GRPC_STATUS_OK;
 }
 
-template <typename Derived, typename... Traits>
-MetadataMap<Derived, Traits...>::MetadataMap(Arena* arena) : unknown_(arena) {}
-
 template <typename Derived, typename... Traits>
 MetadataMap<Derived, Traits...>::MetadataMap(MetadataMap&& other) noexcept
     : table_(std::move(other.table_)), unknown_(std::move(other.unknown_)) {}
@@ -1479,7 +1555,7 @@ size_t MetadataMap<Derived, Traits...>::TransportSize() const {
 
 template <typename Derived, typename... Traits>
 Derived MetadataMap<Derived, Traits...>::Copy() const {
-  Derived out(unknown_.arena());
+  Derived out;
   metadata_detail::CopySink<Derived> sink(&out);
   ForEach(&sink);
   return out;
@@ -1511,7 +1587,8 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
     grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,
     grpc_core::GrpcCallWasCancelled, grpc_core::WaitForReady,
-    grpc_core::GrpcTrailersOnly, grpc_core::GrpcTarPit,
+    grpc_core::IsTransparentRetry, grpc_core::GrpcTrailersOnly,
+    grpc_core::GrpcTarPit,
     grpc_core::GrpcRegisteredMethod GRPC_CUSTOM_CLIENT_METADATA
         GRPC_CUSTOM_SERVER_METADATA>;
 

data/src/core/lib/transport/metadata_compression_traits.h

@@ -16,7 +16,6 @@
 #define GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_COMPRESSION_TRAITS_H
 
 #include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 namespace grpc_core {