grpc 1.56.2 → 1.58.0

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

@@ -20,6 +20,14 @@
 
 #include "src/core/lib/channel/call_tracer.h"
 
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/promise/context.h"
+
 namespace grpc_core {
 
 //
@@ -27,6 +35,7 @@ namespace grpc_core {
 //
 
 namespace {
+
 ServerCallTracerFactory* g_server_call_tracer_factory_ = nullptr;
 
 const char* kServerCallTracerFactoryChannelArgName =
@@ -48,4 +57,284 @@ absl::string_view ServerCallTracerFactory::ChannelArgName() {
   return kServerCallTracerFactoryChannelArgName;
 }
 
+class DelegatingClientCallTracer : public ClientCallTracer {
+ public:
+  class DelegatingClientCallAttemptTracer
+      : public ClientCallTracer::CallAttemptTracer {
+   public:
+    explicit DelegatingClientCallAttemptTracer(
+        std::vector<CallAttemptTracer*> tracers)
+        : tracers_(std::move(tracers)) {
+      GPR_DEBUG_ASSERT(!tracers_.empty());
+    }
+    ~DelegatingClientCallAttemptTracer() override {}
+    void RecordSendInitialMetadata(
+        grpc_metadata_batch* send_initial_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendInitialMetadata(send_initial_metadata);
+      }
+    }
+    void RecordSendTrailingMetadata(
+        grpc_metadata_batch* send_trailing_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendTrailingMetadata(send_trailing_metadata);
+      }
+    }
+    void RecordSendMessage(const SliceBuffer& send_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendMessage(send_message);
+      }
+    }
+    void RecordSendCompressedMessage(
+        const SliceBuffer& send_compressed_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordSendCompressedMessage(send_compressed_message);
+      }
+    }
+    void RecordReceivedInitialMetadata(
+        grpc_metadata_batch* recv_initial_metadata) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
+      }
+    }
+    void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedMessage(recv_message);
+      }
+    }
+    void RecordReceivedDecompressedMessage(
+        const SliceBuffer& recv_decompressed_message) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
+      }
+    }
+    void RecordCancel(grpc_error_handle cancel_error) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordCancel(cancel_error);
+      }
+    }
+    void RecordReceivedTrailingMetadata(
+        absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
+        const grpc_transport_stream_stats* transport_stream_stats) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordReceivedTrailingMetadata(status, recv_trailing_metadata,
+                                               transport_stream_stats);
+      }
+    }
+    void RecordEnd(const gpr_timespec& latency) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordEnd(latency);
+      }
+    }
+    void RecordAnnotation(absl::string_view annotation) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordAnnotation(annotation);
+      }
+    }
+    void RecordAnnotation(const Annotation& annotation) override {
+      for (auto* tracer : tracers_) {
+        tracer->RecordAnnotation(annotation);
+      }
+    }
+    std::string TraceId() override { return tracers_[0]->TraceId(); }
+    std::string SpanId() override { return tracers_[0]->SpanId(); }
+    bool IsSampled() override { return tracers_[0]->IsSampled(); }
+    bool IsDelegatingTracer() override { return true; }
+
+   private:
+    // There is no additional synchronization needed since filters/interceptors
+    // will be adding call tracers to the context and these are already
+    // synchronized through promises/call combiners (single promise running per
+    // call at any moment).
+    std::vector<CallAttemptTracer*> tracers_;
+  };
+  explicit DelegatingClientCallTracer(ClientCallTracer* tracer)
+      : tracers_{tracer} {}
+  ~DelegatingClientCallTracer() override {}
+  CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) override {
+    std::vector<CallAttemptTracer*> attempt_tracers;
+    attempt_tracers.reserve(tracers_.size());
+    for (auto* tracer : tracers_) {
+      auto* attempt_tracer = tracer->StartNewAttempt(is_transparent_retry);
+      GPR_DEBUG_ASSERT(attempt_tracer != nullptr);
+      attempt_tracers.push_back(attempt_tracer);
+    }
+    return GetContext<Arena>()->ManagedNew<DelegatingClientCallAttemptTracer>(
+        std::move(attempt_tracers));
+  }
+
+  void RecordAnnotation(absl::string_view annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  void RecordAnnotation(const Annotation& annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  std::string TraceId() override { return tracers_[0]->TraceId(); }
+  std::string SpanId() override { return tracers_[0]->SpanId(); }
+  bool IsSampled() override { return tracers_[0]->IsSampled(); }
+  bool IsDelegatingTracer() override { return true; }
+
+  // There is no additional synchronization needed since filters/interceptors
+  // will be adding call tracers to the context and these are already
+  // synchronized through promises/call combiners (single promise running per
+  // call at any moment).
+  void AddTracer(ClientCallTracer* tracer) { tracers_.push_back(tracer); }
+
+ private:
+  std::vector<ClientCallTracer*> tracers_;
+};
+
+class DelegatingServerCallTracer : public ServerCallTracer {
+ public:
+  explicit DelegatingServerCallTracer(ServerCallTracer* tracer)
+      : tracers_{tracer} {}
+  ~DelegatingServerCallTracer() override {}
+  void RecordSendInitialMetadata(
+      grpc_metadata_batch* send_initial_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendInitialMetadata(send_initial_metadata);
+    }
+  }
+  void RecordSendTrailingMetadata(
+      grpc_metadata_batch* send_trailing_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendTrailingMetadata(send_trailing_metadata);
+    }
+  }
+  void RecordSendMessage(const SliceBuffer& send_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendMessage(send_message);
+    }
+  }
+  void RecordSendCompressedMessage(
+      const SliceBuffer& send_compressed_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordSendCompressedMessage(send_compressed_message);
+    }
+  }
+  void RecordReceivedInitialMetadata(
+      grpc_metadata_batch* recv_initial_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedInitialMetadata(recv_initial_metadata);
+    }
+  }
+  void RecordReceivedMessage(const SliceBuffer& recv_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedMessage(recv_message);
+    }
+  }
+  void RecordReceivedDecompressedMessage(
+      const SliceBuffer& recv_decompressed_message) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedDecompressedMessage(recv_decompressed_message);
+    }
+  }
+  void RecordCancel(grpc_error_handle cancel_error) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordCancel(cancel_error);
+    }
+  }
+  void RecordReceivedTrailingMetadata(
+      grpc_metadata_batch* recv_trailing_metadata) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordReceivedTrailingMetadata(recv_trailing_metadata);
+    }
+  }
+  void RecordEnd(const grpc_call_final_info* final_info) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordEnd(final_info);
+    }
+  }
+  void RecordAnnotation(absl::string_view annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  void RecordAnnotation(const Annotation& annotation) override {
+    for (auto* tracer : tracers_) {
+      tracer->RecordAnnotation(annotation);
+    }
+  }
+  std::string TraceId() override { return tracers_[0]->TraceId(); }
+  std::string SpanId() override { return tracers_[0]->SpanId(); }
+  bool IsSampled() override { return tracers_[0]->IsSampled(); }
+  bool IsDelegatingTracer() override { return true; }
+
+  void AddTracer(ServerCallTracer* tracer) { tracers_.push_back(tracer); }
+
+ private:
+  // The ServerCallTracerFilter will be responsible for making sure that the
+  // tracers are added in a thread-safe manner. It is imagined that the filter
+  // will just invoke the factories in the server call tracer factory list
+  // sequentially, removing the need for any synchronization.
+  std::vector<ServerCallTracer*> tracers_;
+};
+
+void AddClientCallTracerToContext(grpc_call_context_element* call_context,
+                                  ClientCallTracer* tracer) {
+  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
+      nullptr) {
+    // This is the first call tracer. Set it directly.
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
+        nullptr;
+  } else {
+    // There was already a call tracer present.
+    auto* orig_tracer = static_cast<ClientCallTracer*>(
+        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    if (orig_tracer->IsDelegatingTracer()) {
+      // We already created a delegating tracer. Just add the new tracer to the
+      // list.
+      static_cast<DelegatingClientCallTracer*>(orig_tracer)->AddTracer(tracer);
+    } else {
+      // Create a new delegating tracer and add the first tracer and the new
+      // tracer to the list.
+      auto* delegating_tracer =
+          GetContext<Arena>()->ManagedNew<DelegatingClientCallTracer>(
+              orig_tracer);
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
+          delegating_tracer;
+      delegating_tracer->AddTracer(tracer);
+    }
+  }
+}
+
+void AddServerCallTracerToContext(grpc_call_context_element* call_context,
+                                  ServerCallTracer* tracer) {
+  GPR_DEBUG_ASSERT(
+      call_context[GRPC_CONTEXT_CALL_TRACER].value ==
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
+      nullptr) {
+    // This is the first call tracer. Set it directly.
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER].value = tracer;
+    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
+        nullptr;
+  } else {
+    // There was already a call tracer present.
+    auto* orig_tracer = static_cast<ServerCallTracer*>(
+        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    if (orig_tracer->IsDelegatingTracer()) {
+      // We already created a delegating tracer. Just add the new tracer to the
+      // list.
+      static_cast<DelegatingServerCallTracer*>(orig_tracer)->AddTracer(tracer);
+    } else {
+      // Create a new delegating tracer and add the first tracer and the new
+      // tracer to the list.
+      auto* delegating_tracer =
+          GetContext<Arena>()->ManagedNew<DelegatingServerCallTracer>(
+              orig_tracer);
+      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
+          delegating_tracer;
+      call_context[GRPC_CONTEXT_CALL_TRACER].value = delegating_tracer;
+      delegating_tracer->AddTracer(tracer);
+    }
+  }
+}
+
 }  // namespace grpc_core

data/src/core/lib/channel/call_tracer.h

@@ -30,6 +30,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -49,14 +50,37 @@ namespace grpc_core {
 // The base class for all tracer implementations.
 class CallTracerAnnotationInterface {
  public:
+  // Enum associated with types of Annotations.
+  enum class AnnotationType {
+    kMetadataSizes,
+    kDoNotUse_MustBeLast,
+  };
+
+  // Base class to define a new type of annotation.
+  class Annotation {
+   public:
+    explicit Annotation(AnnotationType type) : type_(type) {}
+    AnnotationType type() const { return type_; }
+    virtual std::string ToString() const = 0;
+    virtual ~Annotation() = default;
+
+   private:
+    const AnnotationType type_;
+  };
+
   virtual ~CallTracerAnnotationInterface() {}
   // Records an annotation on the call attempt.
   // TODO(yashykt): If needed, extend this to attach attributes with
   // annotations.
   virtual void RecordAnnotation(absl::string_view annotation) = 0;
+  virtual void RecordAnnotation(const Annotation& annotation) = 0;
   virtual std::string TraceId() = 0;
   virtual std::string SpanId() = 0;
   virtual bool IsSampled() = 0;
+  // Indicates whether this tracer is a delegating tracer or not.
+  // `DelegatingClientCallTracer`, `DelegatingClientCallAttemptTracer` and
+  // `DelegatingServerCallTracer` are the only delegating call tracers.
+  virtual bool IsDelegatingTracer() { return false; }
 };
 
 // The base class for CallAttemptTracer and ServerCallTracer.
@@ -161,6 +185,17 @@ class ServerCallTracerFactory {
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
 
+// Convenience functions to add call tracers to a call context. Allows setting
+// multiple call tracers to a single call. It is only valid to add client call
+// tracers before the client_channel filter sees the send_initial_metadata op.
+void AddClientCallTracerToContext(grpc_call_context_element* call_context,
+                                  ClientCallTracer* tracer);
+
+// TODO(yashykt): We want server call tracers to be registered through the
+// ServerCallTracerFactory, which has yet to be made into a list.
+void AddServerCallTracerToContext(grpc_call_context_element* call_context,
+                                  ServerCallTracer* tracer);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_CHANNEL_CALL_TRACER_H

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

@@ -27,6 +27,8 @@
 #include <algorithm>
 #include <initializer_list>
 #include <map>
+#include <memory>
+#include <string>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -34,16 +36,41 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/match.h"
 
 namespace grpc_core {
 
+const grpc_arg_pointer_vtable ChannelArgs::Value::int_vtable_{
+    // copy
+    [](void* p) { return p; },
+    // destroy
+    [](void*) {},
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(reinterpret_cast<intptr_t>(p1),
+                          reinterpret_cast<intptr_t>(p2));
+    },
+};
+
+const grpc_arg_pointer_vtable ChannelArgs::Value::string_vtable_{
+    // copy
+    [](void* p) -> void* {
+      return static_cast<RefCountedString*>(p)->Ref().release();
+    },
+    // destroy
+    [](void* p) { static_cast<RefCountedString*>(p)->Unref(); },
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(static_cast<RefCountedString*>(p1)->as_string_view(),
+                          static_cast<RefCountedString*>(p2)->as_string_view());
+    },
+};
+
 ChannelArgs::Pointer::Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
     : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
 
@@ -99,7 +126,7 @@ bool ChannelArgs::WantMinimalStack() const {
   return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
 }
 
-ChannelArgs::ChannelArgs(AVL<std::string, Value> args)
+ChannelArgs::ChannelArgs(AVL<RefCountedStringValue, Value> args)
     : args_(std::move(args)) {}
 
 ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
@@ -129,54 +156,25 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
 
 grpc_arg ChannelArgs::Value::MakeCArg(const char* name) const {
   char* c_name = const_cast<char*>(name);
-  return Match(
-      rep_,
-      [c_name](int i) { return grpc_channel_arg_integer_create(c_name, i); },
-      [c_name](const std::shared_ptr<const std::string>& s) {
-        return grpc_channel_arg_string_create(c_name,
-                                              const_cast<char*>(s->c_str()));
-      },
-      [c_name](const Pointer& p) {
-        return grpc_channel_arg_pointer_create(c_name, p.c_pointer(),
-                                               p.c_vtable());
-      });
-}
-
-bool ChannelArgs::Value::operator<(const Value& rhs) const {
-  if (rhs.rep_.index() != rep_.index()) return rep_.index() < rhs.rep_.index();
-  switch (rep_.index()) {
-    case 0:
-      return absl::get<int>(rep_) < absl::get<int>(rhs.rep_);
-    case 1:
-      return *absl::get<std::shared_ptr<const std::string>>(rep_) <
-             *absl::get<std::shared_ptr<const std::string>>(rhs.rep_);
-    case 2:
-      return absl::get<Pointer>(rep_) < absl::get<Pointer>(rhs.rep_);
-    default:
-      Crash("unreachable");
+  if (rep_.c_vtable() == &int_vtable_) {
+    return grpc_channel_arg_integer_create(
+        c_name, reinterpret_cast<intptr_t>(rep_.c_pointer()));
   }
-}
-
-bool ChannelArgs::Value::operator==(const Value& rhs) const {
-  if (rhs.rep_.index() != rep_.index()) return false;
-  switch (rep_.index()) {
-    case 0:
-      return absl::get<int>(rep_) == absl::get<int>(rhs.rep_);
-    case 1:
-      return *absl::get<std::shared_ptr<const std::string>>(rep_) ==
-             *absl::get<std::shared_ptr<const std::string>>(rhs.rep_);
-    case 2:
-      return absl::get<Pointer>(rep_) == absl::get<Pointer>(rhs.rep_);
-    default:
-      Crash("unreachable");
+  if (rep_.c_vtable() == &string_vtable_) {
+    return grpc_channel_arg_string_create(
+        c_name, const_cast<char*>(
+                    static_cast<RefCountedString*>(rep_.c_pointer())->c_str()));
   }
+  return grpc_channel_arg_pointer_create(c_name, rep_.c_pointer(),
+                                         rep_.c_vtable());
 }
 
 ChannelArgs::CPtr ChannelArgs::ToC() const {
   std::vector<grpc_arg> c_args;
-  args_.ForEach([&c_args](const std::string& key, const Value& value) {
-    c_args.push_back(value.MakeCArg(key.c_str()));
-  });
+  args_.ForEach(
+      [&c_args](const RefCountedStringValue& key, const Value& value) {
+        c_args.push_back(value.MakeCArg(key.c_str()));
+      });
   return CPtr(static_cast<const grpc_channel_args*>(
       grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size())));
 }
@@ -189,33 +187,44 @@ ChannelArgs ChannelArgs::Set(absl::string_view name, int value) const {
   return Set(name, Value(value));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
-  return ChannelArgs(args_.Add(std::string(key), std::move(value)));
+ChannelArgs ChannelArgs::Set(absl::string_view name, Value value) const {
+  if (const auto* p = args_.Lookup(name)) {
+    if (*p == value) return *this;  // already have this value for this key
+  }
+  return ChannelArgs(args_.Add(RefCountedStringValue(name), std::move(value)));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key,
+ChannelArgs ChannelArgs::Set(absl::string_view name,
                              absl::string_view value) const {
-  return Set(key, std::string(value));
+  return Set(name, std::string(value));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, const char* value) const {
-  return Set(key, std::string(value));
+ChannelArgs ChannelArgs::Set(absl::string_view name, const char* value) const {
+  return Set(name, std::string(value));
 }
 
-ChannelArgs ChannelArgs::Set(absl::string_view key, std::string value) const {
-  return Set(key, Value(std::move(value)));
+ChannelArgs ChannelArgs::Set(absl::string_view name, std::string value) const {
+  return Set(name, Value(std::move(value)));
 }
 
-ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
-  return ChannelArgs(args_.Remove(key));
+ChannelArgs ChannelArgs::Remove(absl::string_view name) const {
+  if (args_.Lookup(name) == nullptr) return *this;
+  return ChannelArgs(args_.Remove(name));
+}
+
+ChannelArgs ChannelArgs::RemoveAllKeysWithPrefix(
+    absl::string_view prefix) const {
+  auto args = args_;
+  args_.ForEach([&](const RefCountedStringValue& key, const Value&) {
+    if (absl::StartsWith(key.as_string_view(), prefix)) args = args.Remove(key);
+  });
+  return ChannelArgs(std::move(args));
 }
 
 absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  const auto* i = v->GetIfInt();
-  if (i == nullptr) return absl::nullopt;
-  return *i;
+  return v->GetIfInt();
 }
 
 absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
@@ -231,9 +240,9 @@ absl::optional<absl::string_view> ChannelArgs::GetString(
     absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  const auto* s = v->GetIfString();
+  const auto s = v->GetIfString();
   if (s == nullptr) return absl::nullopt;
-  return *s;
+  return s->as_string_view();
 }
 
 absl::optional<std::string> ChannelArgs::GetOwnedString(
@@ -254,8 +263,8 @@ void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
 absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  auto* i = v->GetIfInt();
-  if (i == nullptr) {
+  auto i = v->GetIfInt();
+  if (!i.has_value()) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
             std::string(name).c_str());
     return absl::nullopt;
@@ -272,19 +281,24 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   }
 }
 
+std::string ChannelArgs::Value::ToString() const {
+  if (rep_.c_vtable() == &int_vtable_) {
+    return std::to_string(reinterpret_cast<intptr_t>(rep_.c_pointer()));
+  }
+  if (rep_.c_vtable() == &string_vtable_) {
+    return std::string(
+        static_cast<RefCountedString*>(rep_.c_pointer())->as_string_view());
+  }
+  return absl::StrFormat("%p", rep_.c_pointer());
+}
+
 std::string ChannelArgs::ToString() const {
   std::vector<std::string> arg_strings;
-  args_.ForEach([&arg_strings](const std::string& key, const Value& value) {
-    std::string value_str;
-    if (auto* i = value.GetIfInt()) {
-      value_str = std::to_string(*i);
-    } else if (auto* s = value.GetIfString()) {
-      value_str = *s;
-    } else if (auto* p = value.GetIfPointer()) {
-      value_str = absl::StrFormat("%p", p->c_pointer());
-    }
-    arg_strings.push_back(absl::StrCat(key, "=", value_str));
-  });
+  args_.ForEach(
+      [&arg_strings](const RefCountedStringValue& key, const Value& value) {
+        arg_strings.push_back(
+            absl::StrCat(key.as_string_view(), "=", value.ToString()));
+      });
   return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
 }
 
@@ -292,24 +306,26 @@ ChannelArgs ChannelArgs::UnionWith(ChannelArgs other) const {
   if (args_.Empty()) return other;
   if (other.args_.Empty()) return *this;
   if (args_.Height() <= other.args_.Height()) {
-    args_.ForEach([&other](const std::string& key, const Value& value) {
-      other.args_ = other.args_.Add(key, value);
-    });
+    args_.ForEach(
+        [&other](const RefCountedStringValue& key, const Value& value) {
+          other.args_ = other.args_.Add(key, value);
+        });
     return other;
   } else {
     auto result = *this;
-    other.args_.ForEach([&result](const std::string& key, const Value& value) {
-      if (result.args_.Lookup(key) == nullptr) {
-        result.args_ = result.args_.Add(key, value);
-      }
-    });
+    other.args_.ForEach(
+        [&result](const RefCountedStringValue& key, const Value& value) {
+          if (result.args_.Lookup(key) == nullptr) {
+            result.args_ = result.args_.Add(key, value);
+          }
+        });
     return result;
   }
 }
 
 ChannelArgs ChannelArgs::FuzzingReferenceUnionWith(ChannelArgs other) const {
   // DO NOT OPTIMIZE THIS!!
-  args_.ForEach([&other](const std::string& key, const Value& value) {
+  args_.ForEach([&other](const RefCountedStringValue& key, const Value& value) {
     other.args_ = other.args_.Add(key, value);
   });
   return other;