grpc 1.43.1 → 1.46.2

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

@@ -23,83 +23,216 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <cstdint>
+
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
 
-static int64_t round_up(int64_t x, int64_t divisor) {
-  return (x / divisor + (x % divisor != 0)) * divisor;
+namespace grpc_core {
+
+namespace {
+
+int64_t DivideRoundingUp(int64_t dividend, int64_t divisor) {
+  return (dividend + divisor - 1) / divisor;
 }
 
-/* round an integer up to the next value with three significant figures */
-static int64_t round_up_to_three_sig_figs(int64_t x) {
-  if (x < 1000) return x;
-  if (x < 10000) return round_up(x, 10);
-  if (x < 100000) return round_up(x, 100);
-  if (x < 1000000) return round_up(x, 1000);
-  if (x < 10000000) return round_up(x, 10000);
-  if (x < 100000000) return round_up(x, 100000);
-  if (x < 1000000000) return round_up(x, 1000000);
-  return round_up(x, 10000000);
+constexpr int64_t kSecondsPerMinute = 60;
+constexpr int64_t kMinutesPerHour = 60;
+constexpr int64_t kMaxHours = 27000;
+
+bool IsAllSpace(const uint8_t* p, const uint8_t* end) {
+  while (p != end && *p == ' ') p++;
+  return p == end;
 }
 
-/* encode our minimum viable timeout value */
-static void enc_tiny(char* buffer) { memcpy(buffer, "1n", 3); }
+}  // namespace
 
-/* encode our maximum timeout value, about 1157 days */
-static void enc_huge(char* buffer) { memcpy(buffer, "99999999S", 10); }
+Timeout Timeout::FromDuration(Duration duration) {
+  return Timeout::FromMillis(duration.millis());
+}
 
-static void enc_ext(char* buffer, int64_t value, char ext) {
-  int n = int64_ttoa(value, buffer);
-  buffer[n] = ext;
-  buffer[n + 1] = 0;
+double Timeout::RatioVersus(Timeout other) const {
+  double a = AsDuration().millis();
+  double b = other.AsDuration().millis();
+  if (b == 0) {
+    if (a > 0) return 100;
+    if (a < 0) return -100;
+    return 0;
+  }
+  return 100 * (a / b - 1);
 }
 
-static void enc_seconds(char* buffer, int64_t sec) {
-  sec = round_up_to_three_sig_figs(sec);
-  if (sec % 3600 == 0) {
-    enc_ext(buffer, sec / 3600, 'H');
-  } else if (sec % 60 == 0) {
-    enc_ext(buffer, sec / 60, 'M');
-  } else {
-    enc_ext(buffer, sec, 'S');
+Duration Timeout::AsDuration() const {
+  int64_t value = value_;
+  switch (unit_) {
+    case Unit::kNanoseconds:
+      return Duration::Zero();
+    case Unit::kMilliseconds:
+      return Duration::Milliseconds(value);
+    case Unit::kTenMilliseconds:
+      return Duration::Milliseconds(value * 10);
+    case Unit::kHundredMilliseconds:
+      return Duration::Milliseconds(value * 100);
+    case Unit::kSeconds:
+      return Duration::Seconds(value);
+    case Unit::kTenSeconds:
+      return Duration::Seconds(value * 10);
+    case Unit::kHundredSeconds:
+      return Duration::Seconds(value * 100);
+    case Unit::kMinutes:
+      return Duration::Minutes(value);
+    case Unit::kTenMinutes:
+      return Duration::Minutes(value * 10);
+    case Unit::kHundredMinutes:
+      return Duration::Minutes(value * 100);
+    case Unit::kHours:
+      return Duration::Hours(value);
   }
+  GPR_UNREACHABLE_CODE(return Duration::NegativeInfinity());
 }
 
-static void enc_millis(char* buffer, int64_t x) {
-  x = round_up_to_three_sig_figs(x);
-  if (x < GPR_MS_PER_SEC) {
-    enc_ext(buffer, x, 'm');
+Slice Timeout::Encode() const {
+  char buf[10];
+  char* p = buf;
+  uint16_t n = value_;
+  int digits;
+  if (n >= 10000) {
+    digits = 5;
+  } else if (n >= 1000) {
+    digits = 4;
+  } else if (n >= 100) {
+    digits = 3;
+  } else if (n >= 10) {
+    digits = 2;
   } else {
-    if (x % GPR_MS_PER_SEC == 0) {
-      enc_seconds(buffer, x / GPR_MS_PER_SEC);
-    } else {
-      enc_ext(buffer, x, 'm');
+    digits = 1;
+  }
+  switch (digits) {
+    case 5:
+      *p++ = '0' + n / 10000;
+      n %= 10000;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 4:
+      *p++ = '0' + n / 1000;
+      n %= 1000;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 3:
+      *p++ = '0' + n / 100;
+      n %= 100;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 2:
+      *p++ = '0' + n / 10;
+      n %= 10;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 1:
+      *p++ = '0' + n;
+  }
+  switch (unit_) {
+    case Unit::kNanoseconds:
+      *p++ = 'n';
+      break;
+    case Unit::kHundredMilliseconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenMilliseconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kMilliseconds:
+      *p++ = 'm';
+      break;
+    case Unit::kHundredSeconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenSeconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kSeconds:
+      *p++ = 'S';
+      break;
+    case Unit::kHundredMinutes:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenMinutes:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kMinutes:
+      *p++ = 'M';
+      break;
+    case Unit::kHours:
+      *p++ = 'H';
+      break;
+  }
+  return Slice::FromCopiedBuffer(buf, p - buf);
+}
+
+Timeout Timeout::FromMillis(int64_t millis) {
+  if (millis <= 0) {
+    return Timeout(1, Unit::kNanoseconds);
+  } else if (millis < 1000) {
+    return Timeout(millis, Unit::kMilliseconds);
+  } else if (millis < 10000) {
+    int64_t value = DivideRoundingUp(millis, 10);
+    if (value % 100 != 0) return Timeout(value, Unit::kTenMilliseconds);
+  } else if (millis < 100000) {
+    int64_t value = DivideRoundingUp(millis, 100);
+    if (value % 10 != 0) return Timeout(value, Unit::kHundredMilliseconds);
+  }
+  return Timeout::FromSeconds(DivideRoundingUp(millis, 1000));
+}
+
+Timeout Timeout::FromSeconds(int64_t seconds) {
+  GPR_DEBUG_ASSERT(seconds != 0);
+  if (seconds < 1000) {
+    if (seconds % kSecondsPerMinute != 0) {
+      return Timeout(seconds, Unit::kSeconds);
+    }
+  } else if (seconds < 10000) {
+    int64_t value = DivideRoundingUp(seconds, 10);
+    if ((value * 10) % kSecondsPerMinute != 0) {
+      return Timeout(value, Unit::kTenSeconds);
+    }
+  } else if (seconds < 100000) {
+    int64_t value = DivideRoundingUp(seconds, 100);
+    if ((value * 100) % kSecondsPerMinute != 0) {
+      return Timeout(value, Unit::kHundredSeconds);
     }
   }
+  return Timeout::FromMinutes(DivideRoundingUp(seconds, kSecondsPerMinute));
 }
 
-void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer) {
-  const grpc_millis kMaxTimeout = 99999999000;
-  if (timeout <= 0) {
-    enc_tiny(buffer);
-  } else if (timeout < 1000 * GPR_MS_PER_SEC) {
-    enc_millis(buffer, timeout);
-  } else if (timeout >= kMaxTimeout) {
-    enc_huge(buffer);
-  } else {
-    enc_seconds(buffer,
-                timeout / GPR_MS_PER_SEC + (timeout % GPR_MS_PER_SEC != 0));
+Timeout Timeout::FromMinutes(int64_t minutes) {
+  GPR_DEBUG_ASSERT(minutes != 0);
+  if (minutes < 1000) {
+    if (minutes % kMinutesPerHour != 0) {
+      return Timeout(minutes, Unit::kMinutes);
+    }
+  } else if (minutes < 10000) {
+    int64_t value = DivideRoundingUp(minutes, 10);
+    if ((value * 10) % kMinutesPerHour != 0) {
+      return Timeout(value, Unit::kTenMinutes);
+    }
+  } else if (minutes < 100000) {
+    int64_t value = DivideRoundingUp(minutes, 100);
+    if ((value * 100) % kMinutesPerHour != 0) {
+      return Timeout(value, Unit::kHundredMinutes);
+    }
   }
+  return Timeout::FromHours(DivideRoundingUp(minutes, kMinutesPerHour));
 }
 
-static int is_all_whitespace(const char* p, const char* end) {
-  while (p != end && *p == ' ') p++;
-  return p == end;
+Timeout Timeout::FromHours(int64_t hours) {
+  GPR_DEBUG_ASSERT(hours != 0);
+  if (hours < kMaxHours) {
+    return Timeout(hours, Unit::kHours);
+  }
+  return Timeout(kMaxHours, Unit::kHours);
 }
 
-int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout) {
-  grpc_millis x = 0;
-  const uint8_t* p = GRPC_SLICE_START_PTR(text);
-  const uint8_t* end = GRPC_SLICE_END_PTR(text);
+absl::optional<Duration> ParseTimeout(const Slice& text) {
+  int32_t x = 0;
+  const uint8_t* p = text.begin();
+  const uint8_t* end = text.end();
   int have_digit = 0;
   /* skip whitespace */
   for (; p != end && *p == ' '; p++) {
@@ -111,41 +244,45 @@ int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout) {
     /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
     if (x >= (100 * 1000 * 1000)) {
       if (x != (100 * 1000 * 1000) || digit != 0) {
-        *timeout = GRPC_MILLIS_INF_FUTURE;
-        return 1;
+        return Duration::Infinity();
       }
     }
     x = x * 10 + digit;
   }
-  if (!have_digit) return 0;
+  if (!have_digit) return absl::nullopt;
   /* skip whitespace */
   for (; p != end && *p == ' '; p++) {
   }
-  if (p == end) return 0;
+  if (p == end) return absl::nullopt;
   /* decode unit specifier */
+  Duration timeout;
   switch (*p) {
     case 'n':
-      *timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
+      timeout =
+          Duration::Milliseconds(x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0));
       break;
     case 'u':
-      *timeout = x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0);
+      timeout =
+          Duration::Milliseconds(x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0));
       break;
     case 'm':
-      *timeout = x;
+      timeout = Duration::Milliseconds(x);
       break;
     case 'S':
-      *timeout = x * GPR_MS_PER_SEC;
+      timeout = Duration::Seconds(x);
       break;
     case 'M':
-      *timeout = x * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Minutes(x);
       break;
     case 'H':
-      *timeout = x * 60 * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Hours(x);
       break;
     default:
-      return 0;
+      return absl::nullopt;
   }
   p++;
-  return is_all_whitespace(reinterpret_cast<const char*>(p),
-                           reinterpret_cast<const char*>(end));
+  if (!IsAllSpace(p, end)) return absl::nullopt;
+  return timeout;
 }
+
+}  // namespace grpc_core

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

@@ -21,18 +21,48 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
-#include <grpc/support/time.h>
-
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+class Timeout {
+ public:
+  static Timeout FromDuration(Duration duration);
+
+  // Computes: 100 * ((this - other) / other)
+  double RatioVersus(Timeout other) const;
+  Slice Encode() const;
+  Duration AsDuration() const;
+
+ private:
+  enum class Unit : uint8_t {
+    kNanoseconds,
+    kMilliseconds,
+    kTenMilliseconds,
+    kHundredMilliseconds,
+    kSeconds,
+    kTenSeconds,
+    kHundredSeconds,
+    kMinutes,
+    kTenMinutes,
+    kHundredMinutes,
+    kHours,
+  };
+
+  Timeout(uint16_t value, Unit unit) : value_(value), unit_(unit) {}
+
+  static Timeout FromMillis(int64_t millis);
+  static Timeout FromSeconds(int64_t seconds);
+  static Timeout FromMinutes(int64_t minutes);
+  static Timeout FromHours(int64_t hours);
+
+  uint16_t value_;
+  Unit unit_;
+};
 
-#define GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE 10
+absl::optional<Duration> ParseTimeout(const Slice& text);
 
-/* Encode/decode timeouts to the GRPC over HTTP/2 format;
-   encoding may round up arbitrarily. If the timeout is larger than about 1157
-   days, it will be capped and "99999999S" will be sent on the wire. */
-void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer);
-int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */

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

@@ -224,7 +224,9 @@ static void destroy_made_transport_stream_op(void* arg,
   made_transport_stream_op* op = static_cast<made_transport_stream_op*>(arg);
   grpc_closure* c = op->inner_on_complete;
   delete op;
-  grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+  if (c != nullptr) {
+    grpc_core::Closure::Run(DEBUG_LOCATION, c, GRPC_ERROR_REF(error));
+  }
 }
 
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(

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

@@ -24,13 +24,15 @@
 #include <stddef.h>
 
 #include "src/core/lib/channel/context.h"
-#include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -42,6 +44,93 @@
 #define GRPC_PROTOCOL_VERSION_MIN_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MIN_MINOR 1
 
+#define GRPC_ARG_TRANSPORT "grpc.internal.transport"
+
+namespace grpc_core {
+// TODO(ctiller): eliminate once MetadataHandle is constructable directly.
+namespace promise_filter_detail {
+class BaseCallData;
+}
+
+// Small unowned "handle" type to ensure one accessor at a time to metadata.
+// The focus here is to get promises to use the syntax we'd like - we'll
+// probably substitute some other smart pointer later.
+template <typename T>
+class MetadataHandle {
+ public:
+  MetadataHandle() = default;
+
+  MetadataHandle(const MetadataHandle&) = delete;
+  MetadataHandle& operator=(const MetadataHandle&) = delete;
+
+  MetadataHandle(MetadataHandle&& other) noexcept : handle_(other.handle_) {
+    other.handle_ = nullptr;
+  }
+  MetadataHandle& operator=(MetadataHandle&& other) noexcept {
+    handle_ = other.handle_;
+    other.handle_ = nullptr;
+    return *this;
+  }
+
+  explicit MetadataHandle(const absl::Status& status) {
+    handle_ = GetContext<Arena>()->New<T>(GetContext<Arena>());
+    handle_->Set(GrpcStatusMetadata(),
+                 static_cast<grpc_status_code>(status.code()));
+    if (status.ok()) return;
+    handle_->Set(GrpcMessageMetadata(),
+                 Slice::FromCopiedString(status.message()));
+  }
+
+  T* operator->() const { return handle_; }
+  bool has_value() const { return handle_ != nullptr; }
+  T* get() const { return handle_; }
+
+  static MetadataHandle TestOnlyWrap(T* p) { return MetadataHandle(p); }
+
+ private:
+  friend class promise_filter_detail::BaseCallData;
+
+  explicit MetadataHandle(T* handle) : handle_(handle) {}
+  T* Unwrap() {
+    T* result = handle_;
+    handle_ = nullptr;
+    return result;
+  }
+
+  T* handle_ = nullptr;
+};
+
+// Server metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ServerMetadata = grpc_metadata_batch;
+using ServerMetadataHandle = MetadataHandle<ServerMetadata>;
+
+// Ok/not-ok check for trailing metadata, so that it can be used as result types
+// for TrySeq.
+inline bool IsStatusOk(const ServerMetadataHandle& m) {
+  return m->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
+         GRPC_STATUS_OK;
+}
+
+// Client initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ClientMetadata = grpc_metadata_batch;
+using ClientMetadataHandle = MetadataHandle<ClientMetadata>;
+
+// Server initial metadata type
+// TODO(ctiller): This should be a bespoke instance of MetadataMap<>
+using ServerMetadataHandle = MetadataHandle<grpc_metadata_batch>;
+
+struct CallArgs {
+  ClientMetadataHandle client_initial_metadata;
+  Latch<ServerMetadata*>* server_initial_metadata;
+};
+
+using NextPromiseFactory =
+    std::function<ArenaPromise<ServerMetadataHandle>(CallArgs)>;
+
+}  // namespace grpc_core
+
 /* forward declarations */
 
 typedef struct grpc_transport grpc_transport;
@@ -278,8 +367,11 @@ struct grpc_transport_stream_op_batch_payload {
     /** Should be enqueued when initial metadata is ready to be processed. */
     grpc_closure* recv_initial_metadata_ready = nullptr;
     // If not NULL, will be set to true if trailing metadata is
-    // immediately available.  This may be a signal that we received a
-    // Trailers-Only response.
+    // immediately available. This may be a signal that we received a
+    // Trailers-Only response. The retry filter checks this to know whether to
+    // defer the decision to commit the call or not. The C++ callback API also
+    // uses this to set the success flag of OnReadInitialMetadataDone()
+    // callback.
     bool* trailing_metadata_available = nullptr;
     // If non-NULL, will be set by the transport to the peer string (a char*).
     // The transport retains ownership of the string.
@@ -353,6 +445,14 @@ typedef struct grpc_transport_op {
   void (*set_accept_stream_fn)(void* user_data, grpc_transport* transport,
                                const void* server_data) = nullptr;
   void* set_accept_stream_user_data = nullptr;
+  /** set the callback for accepting new streams based upon promises;
+      this is a permanent callback, unlike the other one-shot closures.
+      If true, the callback is set to set_make_promise_fn, with its
+      user_data argument set to set_make_promise_data */
+  bool set_make_promise = false;
+  void (*set_make_promise_fn)(void* user_data, grpc_transport* transport,
+                              const void* server_data) = nullptr;
+  void* set_make_promise_user_data = nullptr;
   /** add this transport to a pollset */
   grpc_pollset* bind_pollset = nullptr;
   /** add this transport to a pollset_set */

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

@@ -36,6 +36,18 @@ typedef struct grpc_transport_vtable {
                      grpc_stream_refcount* refcount, const void* server_data,
                      grpc_core::Arena* arena);
 
+  /* Create a promise to execute one client call.
+     If this is non-null, it may be used in preference to
+     perform_stream_op.
+     If this is used in preference to perform_stream_op, the
+     following can be omitted also:
+       - calling init_stream, destroy_stream, set_pollset, set_pollset_set
+       - allocation of memory for call data (sizeof_stream may be ignored)
+     There is an on-going migration to move all filters to providing this, and
+     then to drop perform_stream_op. */
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
+      grpc_transport* self, grpc_core::ClientMetadataHandle initial_metadata);
+
   /* implementation of grpc_transport_set_pollset */
   void (*set_pollset)(grpc_transport* self, grpc_stream* stream,
                       grpc_pollset* pollset);
@@ -64,6 +76,8 @@ typedef struct grpc_transport_vtable {
 
 /* an instance of a grpc transport */
 struct grpc_transport {
+  struct RawPointerChannelArgTag {};
+  static absl::string_view ChannelArgName() { return GRPC_ARG_TRANSPORT; }
   /* pointer to a vtable defining operations on this transport */
   const grpc_transport_vtable* vtable;
 };

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

@@ -25,6 +25,7 @@
 
 #include <vector>
 
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -40,57 +41,14 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-namespace {
-class MetadataListEncoder {
- public:
-  explicit MetadataListEncoder(std::vector<std::string>* out) : out_(out) {}
-  void Encode(const grpc_mdelem& md) {
-    MaybeAddComma();
-    out_->push_back("key=");
-    char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    out_->push_back(dump);
-    gpr_free(dump);
-    out_->push_back(" value=");
-    dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    out_->push_back(dump);
-    gpr_free(dump);
-  }
-
-  void Encode(grpc_core::GrpcTimeoutMetadata, grpc_millis deadline) {
-    MaybeAddComma();
-    out_->push_back(absl::StrFormat("deadline=%" PRId64, deadline));
-  }
-
-  template <typename Which>
-  void Encode(Which, const typename Which::ValueType& value) {
-    MaybeAddComma();
-    out_->push_back(
-        absl::StrCat(Which::key(), "=", Which::DisplayValue(value)));
-  }
-
- private:
-  void MaybeAddComma() {
-    if (out_->size() != initial_size_) out_->push_back(", ");
-  }
-  std::vector<std::string>* const out_;
-  const size_t initial_size_ = out_->size();
-};
-}  // namespace
-
-static void put_metadata_list(const grpc_metadata_batch& md,
-                              std::vector<std::string>* out) {
-  MetadataListEncoder encoder(out);
-  md.Encode(&encoder);
-}
-
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op) {
   std::vector<std::string> out;
 
   if (op->send_initial_metadata) {
     out.push_back(" SEND_INITIAL_METADATA{");
-    put_metadata_list(*op->payload->send_initial_metadata.send_initial_metadata,
-                      &out);
+    out.push_back(op->payload->send_initial_metadata.send_initial_metadata
+                      ->DebugString());
     out.push_back("}");
   }
 
@@ -109,8 +67,8 @@ std::string grpc_transport_stream_op_batch_string(
 
   if (op->send_trailing_metadata) {
     out.push_back(" SEND_TRAILING_METADATA{");
-    put_metadata_list(
-        *op->payload->send_trailing_metadata.send_trailing_metadata, &out);
+    out.push_back(op->payload->send_trailing_metadata.send_trailing_metadata
+                      ->DebugString());
     out.push_back("}");
   }