grpc 1.45.0 → 1.47.0

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -26,8 +26,10 @@
 
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_replace.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -36,33 +38,41 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #include <sys/un.h>
 #endif
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
-static std::string grpc_sockaddr_to_uri_unix_if_possible(
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr) {
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family != AF_UNIX) {
-    return "";
+    return absl::InvalidArgumentError(
+        absl::StrCat("Socket family is not AF_UNIX: ", addr->sa_family));
   }
   const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  std::string scheme, path;
   if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
-    return absl::StrCat(
-        "unix-abstract:",
-        absl::string_view(
-            unix_addr->sun_path + 1,
-            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
+    scheme = "unix-abstract";
+    path = std::string(unix_addr->sun_path + 1,
+                       resolved_addr->len - sizeof(unix_addr->sun_family) - 1);
+  } else {
+    scheme = "unix";
+    path = unix_addr->sun_path;
   }
-  return absl::StrCat("unix:", unix_addr->sun_path);
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      std::move(scheme), /*authority=*/"", std::move(path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  if (!uri.ok()) return uri.status();
+  return uri->ToString();
 }
 #else
-static std::string grpc_sockaddr_to_uri_unix_if_possible(
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* /* addr */) {
-  return "";
+  return absl::InvalidArgumentError("Unix socket is not supported.");
 }
 #endif
 
@@ -182,8 +192,8 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
-                                    bool normalize) {
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* resolved_addr, bool normalize) {
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
@@ -191,6 +201,28 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   }
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  std::string out;
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  if (addr->sa_family == GRPC_AF_UNIX) {
+    const sockaddr_un* addr_un = reinterpret_cast<const sockaddr_un*>(addr);
+    bool abstract = addr_un->sun_path[0] == '\0';
+    if (abstract) {
+      int len = resolved_addr->len - sizeof(addr->sa_family);
+      if (len <= 0) {
+        return absl::InvalidArgumentError("empty UDS abstract path");
+      }
+      out = std::string(addr_un->sun_path, len);
+    } else {
+      size_t maxlen = sizeof(addr_un->sun_path);
+      if (strnlen(addr_un->sun_path, maxlen) == maxlen) {
+        return absl::InvalidArgumentError("UDS path is not null-terminated");
+      }
+      out = std::string(addr_un->sun_path);
+    }
+    return out;
+  }
+#endif
+
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -207,7 +239,6 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
     sin6_scope_id = addr6->sin6_scope_id;
   }
   char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  std::string out;
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
@@ -219,15 +250,19 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
       out = grpc_core::JoinHostPort(ntop_buf, port);
     }
   } else {
-    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
+    return absl::InvalidArgumentError(
+        absl::StrCat("Unknown sockaddr family: ", addr->sa_family));
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
   return out;
 }
 
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return "";
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* resolved_addr) {
+  if (resolved_addr->len == 0) {
+    return absl::InvalidArgumentError("Empty address");
+  }
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
@@ -236,13 +271,11 @@ std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  std::string path =
-      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  std::string uri_str;
-  if (scheme != nullptr) {
-    uri_str = absl::StrCat(scheme, ":", path);
-  }
-  return uri_str;
+  // TODO(anramach): Encode the string using URI::Create() and URI::ToString()
+  // before returning.
+  auto path = grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
+  if (!path.ok()) return path;
+  return absl::StrCat(scheme, ":", path.value());
 }
 
 const char* grpc_sockaddr_get_uri_scheme(

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -23,6 +23,8 @@
 
 #include <string>
 
+#include "absl/status/statusor.h"
+
 #include "src/core/lib/iomgr/resolved_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
@@ -60,14 +62,15 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 
 // Converts a sockaddr into a newly-allocated human-readable string.
 //
-// Currently, only the AF_INET and AF_INET6 families are recognized.
+// Currently, only the AF_INET, AF_INET6, and AF_UNIX families are recognized.
 // If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
 // displayed as plain IPv4.
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
-                                    bool normalize) GRPC_MUST_USE_RESULT;
+absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* addr, bool normalize) GRPC_MUST_USE_RESULT;
 
 /* Returns the URI string corresponding to \a addr */
-std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
+absl::StatusOr<std::string> grpc_sockaddr_to_uri(
+    const grpc_resolved_address* addr);
 
 /* Returns the URI scheme corresponding to \a addr */
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);

data/src/core/lib/avl/avl.h

@@ -19,8 +19,10 @@
 
 #include <stdlib.h>
 
-#include <algorithm>
 #include <memory>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
 
 namespace grpc_core {
 
@@ -32,8 +34,12 @@ class AVL {
   AVL Add(K key, V value) const {
     return AVL(AddKey(root_, std::move(key), std::move(value)));
   }
-  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
-  const V* Lookup(const K& key) const {
+  template <typename SomethingLikeK>
+  AVL Remove(const SomethingLikeK& key) const {
+    return AVL(RemoveKey(root_, key));
+  }
+  template <typename SomethingLikeK>
+  const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
     return n ? &n->kv.second : nullptr;
   }
@@ -50,10 +56,40 @@ class AVL {
     ForEachImpl(root_.get(), std::forward<F>(f));
   }
 
-  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+  bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
+
+  bool operator==(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q == nullptr;
+      if (q == nullptr) return false;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
+
+  bool operator<(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q != nullptr;
+      if (q == nullptr) return false;
+      if (p->kv < q->kv) return true;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, V v, NodePtr l, NodePtr r, long h)
@@ -68,6 +104,32 @@ class AVL {
   };
   NodePtr root_;
 
+  class Iterator {
+   public:
+    explicit Iterator(const NodePtr& root) {
+      auto* n = root.get();
+      while (n != nullptr) {
+        stack_.push_back(n);
+        n = n->left.get();
+      }
+    }
+    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    void MoveNext() {
+      auto* n = stack_.back();
+      stack_.pop_back();
+      if (n->right != nullptr) {
+        n = n->right.get();
+        while (n != nullptr) {
+          stack_.push_back(n);
+          n = n->left.get();
+        }
+      }
+    }
+
+   private:
+    absl::InlinedVector<Node*, 8> stack_;
+  };
+
   explicit AVL(NodePtr root) : root_(std::move(root)) {}
 
   template <class F>
@@ -86,7 +148,8 @@ class AVL {
                                   1 + std::max(Height(left), Height(right)));
   }
 
-  static NodePtr Get(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr Get(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -198,7 +261,8 @@ class AVL {
     return node;
   }
 
-  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr RemoveKey(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -246,6 +310,7 @@ class AVL<K, void> {
 
  private:
   struct Node;
+
   typedef std::shared_ptr<Node> NodePtr;
   struct Node : public std::enable_shared_from_this<Node> {
     Node(K k, NodePtr l, NodePtr r, long h)

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

@@ -17,6 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <utility>
+
+#include "absl/utility/utility.h"
+
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"

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

@@ -21,11 +21,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/string_view.h"
+#include <stdint.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "absl/status/status.h"
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/atm.h>
+
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/byte_stream.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -59,9 +65,12 @@ class CallTracer {
     virtual void RecordReceivedInitialMetadata(
         grpc_metadata_batch* recv_initial_metadata, uint32_t flags) = 0;
     virtual void RecordReceivedMessage(const ByteStream& recv_message) = 0;
+    // If the call was cancelled before the recv_trailing_metadata op
+    // was started, recv_trailing_metadata and transport_stream_stats
+    // will be null.
     virtual void RecordReceivedTrailingMetadata(
         absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
-        const grpc_transport_stream_stats& transport_stream_stats) = 0;
+        const grpc_transport_stream_stats* transport_stream_stats) = 0;
     virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.

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

@@ -21,12 +21,15 @@
 #include "src/core/lib/channel/channel_args.h"
 
 #include <limits.h>
+#include <stdlib.h>
 #include <string.h>
 
+#include <algorithm>
 #include <map>
 #include <vector>
 
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
@@ -35,8 +38,168 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/match.h"
+
+namespace {
+
+int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
+                   void* b_ptr, const grpc_arg_pointer_vtable* b_vtable) {
+  int c = grpc_core::QsortCompare(a_ptr, b_ptr);
+  if (c == 0) return 0;
+  c = grpc_core::QsortCompare(a_vtable, b_vtable);
+  if (c != 0) return c;
+  return a_vtable->cmp(a_ptr, b_ptr);
+}
+
+}  // namespace
+
+namespace grpc_core {
+
+bool ChannelArgs::Pointer::operator==(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) == 0;
+}
+
+bool ChannelArgs::Pointer::operator<(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) < 0;
+}
+
+ChannelArgs::ChannelArgs() = default;
+
+ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
+  switch (arg.type) {
+    case GRPC_ARG_INTEGER:
+      return Set(arg.key, arg.value.integer);
+    case GRPC_ARG_STRING:
+      if (arg.value.string != nullptr) return Set(arg.key, arg.value.string);
+      return Set(arg.key, "");
+    case GRPC_ARG_POINTER:
+      return Set(arg.key,
+                 Pointer(arg.value.pointer.vtable->copy(arg.value.pointer.p),
+                         arg.value.pointer.vtable));
+  }
+  GPR_UNREACHABLE_CODE(return ChannelArgs());
+}
+
+ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
+  ChannelArgs result;
+  if (args != nullptr) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      result = result.Set(args->args[i]);
+    }
+  }
+  return result;
+}
+
+const grpc_channel_args* ChannelArgs::ToC() const {
+  std::vector<grpc_arg> c_args;
+  args_.ForEach([&c_args](const std::string& key, const Value& value) {
+    char* name = const_cast<char*>(key.c_str());
+    c_args.push_back(Match(
+        value,
+        [name](int i) { return grpc_channel_arg_integer_create(name, i); },
+        [name](const std::string& s) {
+          return grpc_channel_arg_string_create(name,
+                                                const_cast<char*>(s.c_str()));
+        },
+        [name](const Pointer& p) {
+          return grpc_channel_arg_pointer_create(name, p.c_pointer(),
+                                                 p.c_vtable());
+        }));
+  });
+  return grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size());
+}
+
+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 key,
+                             absl::string_view value) const {
+  return Set(key, 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 key, std::string value) const {
+  return Set(key, Value(std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
+  return ChannelArgs(args_.Remove(key));
+}
+
+absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<int>(*v)) return absl::nullopt;
+  return absl::get<int>(*v);
+}
+
+absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
+    absl::string_view name) const {
+  auto ms = GetInt(name);
+  if (!ms.has_value()) return absl::nullopt;
+  if (*ms == INT_MAX) return Duration::Infinity();
+  if (*ms == INT_MIN) return Duration::NegativeInfinity();
+  return Duration::Milliseconds(*ms);
+}
+
+absl::optional<absl::string_view> ChannelArgs::GetString(
+    absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<std::string>(*v)) return absl::nullopt;
+  return absl::get<std::string>(*v);
+}
+
+void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return nullptr;
+  if (!absl::holds_alternative<Pointer>(*v)) return nullptr;
+  return absl::get<Pointer>(*v).c_pointer();
+}
+
+absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  auto* i = absl::get_if<int>(v);
+  if (i == nullptr) {
+    gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
+            std::string(name).c_str());
+    return absl::nullopt;
+  }
+  switch (*i) {
+    case 0:
+      return false;
+    case 1:
+      return true;
+    default:
+      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
+              std::string(name).c_str(), *i);
+      return true;
+  }
+}
+
+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 = absl::get_if<int>(&value)) {
+      value_str = std::to_string(*i);
+    } else if (auto* s = absl::get_if<std::string>(&value)) {
+      value_str = *s;
+    } else if (auto* p = absl::get_if<Pointer>(&value)) {
+      value_str = absl::StrFormat("%p", p->c_pointer());
+    }
+    arg_strings.push_back(absl::StrCat(key, "=", value_str));
+  });
+  return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
+}
+
+}  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
@@ -156,16 +319,8 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_INTEGER:
       return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      c = grpc_core::QsortCompare(a->value.pointer.p, b->value.pointer.p);
-      if (c != 0) {
-        c = grpc_core::QsortCompare(a->value.pointer.vtable,
-                                    b->value.pointer.vtable);
-        if (c == 0) {
-          c = a->value.pointer.vtable->cmp(a->value.pointer.p,
-                                           b->value.pointer.p);
-        }
-      }
-      return c;
+      return PointerCompare(a->value.pointer.p, a->value.pointer.vtable,
+                            b->value.pointer.p, b->value.pointer.vtable);
   }
   GPR_UNREACHABLE_CODE(return 0);
 }
@@ -345,49 +500,15 @@ grpc_arg grpc_channel_arg_pointer_create(
 }
 
 std::string grpc_channel_args_string(const grpc_channel_args* args) {
-  if (args == nullptr) return "";
-  std::vector<std::string> arg_strings;
-  for (size_t i = 0; i < args->num_args; ++i) {
-    const grpc_arg& arg = args->args[i];
-    std::string arg_string;
-    switch (arg.type) {
-      case GRPC_ARG_INTEGER:
-        arg_string = absl::StrFormat("%s=%d", arg.key, arg.value.integer);
-        break;
-      case GRPC_ARG_STRING:
-        arg_string = absl::StrFormat("%s=%s", arg.key, arg.value.string);
-        break;
-      case GRPC_ARG_POINTER:
-        arg_string = absl::StrFormat("%s=%p", arg.key, arg.value.pointer.p);
-        break;
-      default:
-        arg_string = "arg with unknown type";
-    }
-    arg_strings.push_back(arg_string);
-  }
-  return absl::StrJoin(arg_strings, ", ");
+  return grpc_core::ChannelArgs::FromC(args).ToString();
 }
 
 namespace grpc_core {
-const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  // Create result.
-  grpc_channel_args* dst =
-      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
-  dst->args =
-      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
-  dst->num_args = 0;
-  for (size_t i = 0; i < src->num_args; ++i) {
-    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
-    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
-  }
-  return dst;
-}
-
-const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  std::map<absl::string_view, const grpc_arg*> values;
-  std::map<absl::string_view, std::vector<std::string>> concatenated_values;
+ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
+  if (src == nullptr) return ChannelArgs();
+  ChannelArgs output;
+  std::map<absl::string_view, std::vector<absl::string_view>>
+      concatenated_values;
   for (size_t i = 0; i < src->num_args; i++) {
     absl::string_view key = src->args[i].key;
     // User-agent strings were traditionally multi-valued and concatenated.
@@ -401,46 +522,23 @@ const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
         concatenated_values[key].push_back(src->args[i].value.string);
       }
       continue;
+    } else if (absl::StartsWith(key, "grpc.internal.")) {
+      continue;
     }
-    auto it = values.find(key);
-    if (it == values.end()) {
-      values[key] = &src->args[i];
+    if (!output.Contains(key)) {
+      output = output.Set(src->args[i]);
     } else {
       // Traditional grpc_channel_args_find behavior was to pick the first
       // value.
       // For compatibility with existing users, we will do the same here.
     }
   }
-  if (values.size() + concatenated_values.size() == src->num_args) {
-    return grpc_channel_args_copy(src);
-  }
   // Concatenate the concatenated values.
-  std::map<absl::string_view, std::string> concatenated_values_str;
   for (const auto& concatenated_value : concatenated_values) {
-    concatenated_values_str[concatenated_value.first] =
-        absl::StrJoin(concatenated_value.second, " ");
-  }
-  // Create the result
-  std::vector<grpc_arg> argv;
-  argv.reserve(values.size());
-  for (const auto& a : values) {
-    argv.push_back(*a.second);
-  }
-  for (const auto& a : concatenated_values_str) {
-    argv.push_back(
-        grpc_channel_arg_string_create(const_cast<char*>(a.first.data()),
-                                       const_cast<char*>(a.second.c_str())));
+    output = output.Set(concatenated_value.first,
+                        absl::StrJoin(concatenated_value.second, " "));
   }
-  grpc_channel_args args = {argv.size(), argv.data()};
-  // Log that we're mutating things
-  gpr_log(GPR_INFO,
-          "Uniquification pass on channel args is mutating them: {%s} is being "
-          "changed to {%s}",
-          grpc_channel_args_string(src).c_str(),
-          grpc_channel_args_string(&args).c_str());
-  // Return the result (note we need to copy because we're borrowing the args
-  // from src still!)
-  return grpc_channel_args_copy(&args);
+  return output;
 }
 }  // namespace grpc_core