grpc 1.80.0 → 1.81.0

data/src/core/xds/grpc/xds_bootstrap_grpc.cc

@@ -36,8 +36,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -55,6 +53,28 @@ bool XdsExtProcOnClientEnabled() {
 // GrpcXdsBootstrap::GrpcNode::Locality
 //
 
+std::string GrpcXdsBootstrap::GrpcNode::Locality::ToString() const {
+  std::string result = "{";
+  bool is_first = true;
+  if (!region.empty()) {
+    StrAppend(result, "region=");
+    StrAppend(result, region);
+    is_first = false;
+  }
+  if (!zone.empty()) {
+    StrAppend(result, is_first ? "zone=" : ", zone=");
+    StrAppend(result, zone);
+    is_first = false;
+  }
+  if (!sub_zone.empty()) {
+    StrAppend(result, is_first ? "sub_zone=" : ", sub_zone=");
+    StrAppend(result, sub_zone);
+    is_first = false;
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
 const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::Locality::JsonLoader(
     const JsonArgs&) {
   static const auto* loader =
@@ -70,6 +90,33 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::Locality::JsonLoader(
 // GrpcXdsBootstrap::GrpcNode
 //
 
+std::string GrpcXdsBootstrap::GrpcNode::ToString() const {
+  std::string result = "{";
+  bool is_first = true;
+  if (!id_.empty()) {
+    StrAppend(result, "id=");
+    StrAppend(result, id_);
+    is_first = false;
+  }
+  if (!cluster_.empty()) {
+    StrAppend(result, is_first ? "cluster=" : ", cluster=");
+    StrAppend(result, cluster_);
+    is_first = false;
+  }
+  if (!locality_.Empty()) {
+    StrAppend(result, is_first ? "locality=" : ", locality=");
+    StrAppend(result, locality_.ToString());
+    is_first = false;
+  }
+  if (!metadata_.empty()) {
+    StrAppend(result, is_first ? "metadata=" : ", metadata=");
+    StrAppend(result, JsonDump(Json::FromObject(metadata_)));
+    is_first = false;
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
 const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::JsonLoader(
     const JsonArgs&) {
   static const auto* loader =
@@ -86,6 +133,30 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::JsonLoader(
 // GrpcXdsBootstrap::GrpcAuthority
 //
 
+std::string GrpcXdsBootstrap::GrpcAuthority::ToString() const {
+  std::string result = "{";
+  bool is_first = false;
+  if (!client_listener_resource_name_template_.empty()) {
+    StrAppend(result, "client_listener_resource_name_template=\"");
+    StrAppend(result, client_listener_resource_name_template_);
+    StrAppend(result, "\"");
+    is_first = false;
+  }
+  if (!servers_.empty()) {
+    StrAppend(result, is_first ? "servers=[" : ", servers=[");
+    bool is_first_server = true;
+    for (const auto& server : servers_) {
+      if (!is_first_server) StrAppend(result, ", ");
+      StrAppend(result, server.Key());
+      is_first_server = false;
+    }
+    StrAppend(result, "]");
+    is_first = false;
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
 const JsonLoaderInterface* GrpcXdsBootstrap::GrpcAuthority::JsonLoader(
     const JsonArgs&) {
   static const auto* loader =
@@ -104,6 +175,29 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcAuthority::JsonLoader(
 // GrpcXdsBootstrap::AllowedGrpcService
 //
 
+std::string GrpcXdsBootstrap::AllowedGrpcService::ToString() const {
+  std::string result = "{";
+  bool is_first = true;
+  if (channel_creds_config != nullptr) {
+    StrAppend(result, "channel_creds={type=");
+    StrAppend(result, channel_creds_config->type());
+    StrAppend(result, ", config=");
+    StrAppend(result, channel_creds_config->ToString());
+    StrAppend(result, "}");
+    is_first = false;
+  }
+  for (const auto& call_creds_config : call_creds_configs) {
+    StrAppend(result, is_first ? "call_creds={type=" : ", call_creds={type=");
+    StrAppend(result, call_creds_config->type());
+    StrAppend(result, ", config=");
+    StrAppend(result, call_creds_config->ToString());
+    StrAppend(result, "}");
+    is_first = false;
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
 const JsonLoaderInterface* GrpcXdsBootstrap::AllowedGrpcService::JsonLoader(
     const JsonArgs&) {
   static const auto* loader = JsonObjectLoader<AllowedGrpcService>().Finish();
@@ -196,84 +290,69 @@ void GrpcXdsBootstrap::JsonPostLoad(const Json& /*json*/,
 }
 
 std::string GrpcXdsBootstrap::ToString() const {
-  std::vector<std::string> parts;
-  if (node_.has_value()) {
-    parts.push_back(
-        absl::StrFormat("node={\n"
-                        "  id=\"%s\",\n"
-                        "  cluster=\"%s\",\n"
-                        "  locality={\n"
-                        "    region=\"%s\",\n"
-                        "    zone=\"%s\",\n"
-                        "    sub_zone=\"%s\"\n"
-                        "  },\n"
-                        "  metadata=%s,\n"
-                        "},\n",
-                        node_->id(), node_->cluster(), node_->locality_region(),
-                        node_->locality_zone(), node_->locality_sub_zone(),
-                        JsonDump(Json::FromObject(node_->metadata()))));
+  std::string result = "{servers=[";
+  bool is_first_server = false;
+  for (const auto& server : servers_) {
+    if (!is_first_server) StrAppend(result, ", ");
+    StrAppend(result, server.Key());
+    is_first_server = false;
   }
-  std::vector<std::string> server_strings;
-  for (auto& server : servers_) {
-    server_strings.emplace_back(server.Key());
+  StrAppend(result, "]");
+  if (node_.has_value()) {
+    StrAppend(result, ",\n  node=");
+    StrAppend(result, node_->ToString());
   }
-  parts.push_back(absl::StrFormat("    servers=[\n%s\n],\n",
-                                  absl::StrJoin(server_strings, ",\n")));
   if (!client_default_listener_resource_name_template_.empty()) {
-    parts.push_back(absl::StrFormat(
-        "client_default_listener_resource_name_template=\"%s\",\n",
-        client_default_listener_resource_name_template_));
+    StrAppend(result, ",\n  client_default_listener_resource_name_template=\"");
+    StrAppend(result, client_default_listener_resource_name_template_);
+    StrAppend(result, "\"");
   }
   if (!server_listener_resource_name_template_.empty()) {
-    parts.push_back(
-        absl::StrFormat("server_listener_resource_name_template=\"%s\",\n",
-                        server_listener_resource_name_template_));
+    StrAppend(result, ",\n  server_listener_resource_name_template=\"");
+    StrAppend(result, server_listener_resource_name_template_);
+    StrAppend(result, "\"");
   }
-  parts.push_back("authorities={\n");
-  for (const auto& [name, authority] : authorities_) {
-    parts.push_back(absl::StrFormat("  %s={\n", name));
-    parts.push_back(
-        absl::StrFormat("    client_listener_resource_name_template=\"%s\",\n",
-                        authority.client_listener_resource_name_template()));
-    std::vector<std::string> server_strings;
-    for (const XdsServer* server : authority.servers()) {
-      server_strings.emplace_back(server->Key());
-    }
-    if (!server_strings.empty()) {
-      parts.push_back(absl::StrFormat("    servers=[\n%s\n],\n",
-                                      absl::StrJoin(server_strings, ",\n")));
+  if (!authorities_.empty()) {
+    StrAppend(result, ",\n  authorities={");
+    bool is_first_authority = true;
+    for (const auto& [name, authority] : authorities_) {
+      StrAppend(result, is_first_authority ? ",\n    " : "\n    ");
+      StrAppend(result, name);
+      StrAppend(result, "=");
+      StrAppend(result, authority.ToString());
+      is_first_authority = false;
     }
-    parts.push_back("      },\n");
-  }
-  parts.push_back("}\n");
-  parts.push_back("certificate_providers={\n");
-  for (const auto& [name, plugin_definition] : certificate_providers_) {
-    parts.push_back(
-        absl::StrFormat("  %s={\n"
-                        "    plugin_name=%s\n"
-                        "    config=%s\n"
-                        "  },\n",
-                        name, plugin_definition.plugin_name,
-                        plugin_definition.config->ToString()));
+    StrAppend(result, "\n  }");
   }
-  parts.push_back("}");
-  parts.push_back("allowed_grpc_services={\n");
-  for (const auto& [target_uri, creds] : allowed_grpc_services_) {
-    parts.push_back(absl::StrCat("  ", target_uri, "={\n"));
-    if (creds.channel_creds_config != nullptr) {
-      parts.push_back(absl::StrCat(
-          "    channel_creds={type=", creds.channel_creds_config->type(),
-          ", config=", creds.channel_creds_config->ToString(), "},\n"));
+  if (!certificate_providers_.empty()) {
+    StrAppend(result, ",\n  certificate_providers={");
+    bool is_first_provider = true;
+    for (const auto& [name, plugin_definition] : certificate_providers_) {
+      StrAppend(result, is_first_provider ? ",\n    " : "\n    ");
+      StrAppend(result, name);
+      StrAppend(result, "={plugin_name=");
+      StrAppend(result, plugin_definition.plugin_name);
+      StrAppend(result, ", config=");
+      StrAppend(result, plugin_definition.config->ToString());
+      StrAppend(result, "}");
+      is_first_provider = false;
     }
-    for (const auto& call_creds_config : creds.call_creds_configs) {
-      parts.push_back(
-          absl::StrCat("    call_creds={type=", call_creds_config->type(),
-                       ", config=", call_creds_config->ToString(), "},\n"));
+    StrAppend(result, "\n  }");
+  }
+  if (!allowed_grpc_services_.empty()) {
+    StrAppend(result, ",\n  allowed_grpc_services={");
+    bool is_first_grpc_service = true;
+    for (const auto& [target_uri, creds] : allowed_grpc_services_) {
+      StrAppend(result, is_first_grpc_service ? ",\n    " : "\n    ");
+      StrAppend(result, target_uri);
+      StrAppend(result, "=");
+      StrAppend(result, creds.ToString());
+      is_first_grpc_service = false;
     }
-    parts.push_back("  },\n");
+    StrAppend(result, "\n  }");
   }
-  parts.push_back("}");
-  return absl::StrJoin(parts, "");
+  StrAppend(result, "\n}");
+  return result;
 }
 
 const XdsBootstrap::Authority* GrpcXdsBootstrap::LookupAuthority(

data/src/core/xds/grpc/xds_bootstrap_grpc.h

@@ -59,6 +59,8 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
     }
     const Json::Object& metadata() const override { return metadata_; }
 
+    std::string ToString() const;
+
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
 
    private:
@@ -67,6 +69,12 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
       std::string zone;
       std::string sub_zone;
 
+      bool Empty() const {
+        return region.empty() && zone.empty() && sub_zone.empty();
+      }
+
+      std::string ToString() const;
+
       static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
     };
 
@@ -95,6 +103,8 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
       return client_listener_resource_name_template_;
     }
 
+    std::string ToString() const;
+
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
 
    private:
@@ -107,6 +117,8 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
     RefCountedPtr<const ChannelCredsConfig> channel_creds_config;
     std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
 
+    std::string ToString() const;
+
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
     void JsonPostLoad(const Json& json, const JsonArgs& args,
                       ValidationErrors* errors);

data/src/core/xds/grpc/xds_client_grpc.cc

@@ -313,7 +313,7 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
                                               certificate_provider_store),
       certificate_provider_store,
       GetStatsPluginGroupForKeyAndChannelArgs(key, args));
-  g_xds_client_map->emplace(xds_client->key(), xds_client.get());
+  g_xds_client_map->insert_or_assign(xds_client->key(), xds_client.get());
   GRPC_TRACE_LOG(xds_client, INFO) << "[xds_client " << xds_client.get()
                                    << "] Created xDS client for key " << key;
   return xds_client;

data/src/core/xds/grpc/xds_cluster.cc

@@ -16,78 +16,95 @@
 
 #include "src/core/xds/grpc/xds_cluster.h"
 
+#include <string>
+
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/match.h"
+#include "src/core/util/string.h"
 #include "src/core/util/time.h"
 #include "src/core/xds/grpc/xds_common_types.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
 
 namespace grpc_core {
 
 std::string XdsClusterResource::UpstreamTlsContext::ToString() const {
-  std::vector<std::string> contents;
+  std::string result = "{";
+  bool is_first = true;
   if (!common_tls_context.Empty()) {
-    contents.push_back(
-        absl::StrCat("common_tls_context=", common_tls_context.ToString()));
+    StrAppend(result, "common_tls_context=");
+    StrAppend(result, common_tls_context.ToString());
+    is_first = false;
+  }
+  if (!sni.empty()) {
+    StrAppend(result, is_first ? "sni=" : ", sni=");
+    StrAppend(result, sni);
+    is_first = false;
   }
-  contents.push_back(absl::StrCat("sni=", sni));
   if (auto_host_sni) {
-    contents.push_back("auto_host_sni=true");
+    StrAppend(result, is_first ? "auto_host_sni=true" : ", auto_host_sni=true");
+    is_first = false;
   }
   if (auto_sni_san_validation) {
-    contents.push_back("auto_sni_san_validation=true");
+    StrAppend(result, is_first ? "auto_sni_san_validation=true"
+                               : ", auto_sni_san_validation=true");
+    is_first = false;
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 std::string XdsClusterResource::ToString() const {
-  std::vector<std::string> contents;
+  std::string result = "{";
   Match(
       type,
       [&](const Eds& eds) {
-        contents.push_back("type=EDS");
+        StrAppend(result, "type=EDS");
         if (!eds.eds_service_name.empty()) {
-          contents.push_back(
-              absl::StrCat("eds_service_name=", eds.eds_service_name));
+          StrAppend(result, ", eds_service_name=");
+          StrAppend(result, eds.eds_service_name);
         }
       },
       [&](const LogicalDns& logical_dns) {
-        contents.push_back("type=LOGICAL_DNS");
-        contents.push_back(absl::StrCat("dns_hostname=", logical_dns.hostname));
+        StrAppend(result, "type=LOGICAL_DNS, dns_hostname=");
+        StrAppend(result, logical_dns.hostname);
       },
       [&](const Aggregate& aggregate) {
-        contents.push_back("type=AGGREGATE");
-        contents.push_back(absl::StrCat(
-            "prioritized_cluster_names=[",
-            absl::StrJoin(aggregate.prioritized_cluster_names, ", "), "]"));
+        StrAppend(result, "type=AGGREGATE, prioritized_cluster_names=[");
+        bool is_first_inner = true;
+        for (const auto& name : aggregate.prioritized_cluster_names) {
+          if (!is_first_inner) StrAppend(result, ", ");
+          StrAppend(result, name);
+          is_first_inner = false;
+        }
+        StrAppend(result, "]");
       });
-  contents.push_back(absl::StrCat("lb_policy_config=",
-                                  JsonDump(Json::FromArray(lb_policy_config))));
+  StrAppend(result, ", lb_policy_config=");
+  StrAppend(result, JsonDump(Json::FromArray(lb_policy_config)));
   if (lrs_load_reporting_server != nullptr) {
-    contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
-                                    lrs_load_reporting_server->server_uri()));
+    StrAppend(result, ", lrs_load_reporting_server_name=");
+    StrAppend(result, lrs_load_reporting_server->server_uri());
   }
   if (lrs_backend_metric_propagation != nullptr) {
-    contents.push_back(
-        absl::StrCat("lrs_backend_metric_propagation=",
-                     lrs_backend_metric_propagation->AsString()));
+    StrAppend(result, ", lrs_backend_metric_propagation=");
+    StrAppend(result, lrs_backend_metric_propagation->AsString());
   }
-  if (use_http_connect) contents.push_back("use_http_connect=true");
-  contents.push_back(
-      absl::StrCat("upstream_tls_context=", upstream_tls_context.ToString()));
+  if (use_http_connect) StrAppend(result, ", use_http_connect=true");
+  StrAppend(result, ", upstream_tls_context=");
+  StrAppend(result, upstream_tls_context.ToString());
   if (connection_idle_timeout != Duration::Zero()) {
-    contents.push_back(absl::StrCat("connection_idle_timeout=",
-                                    connection_idle_timeout.ToString()));
+    StrAppend(result, ", connection_idle_timeout=");
+    StrAppend(result, connection_idle_timeout.ToString());
   }
-  contents.push_back(
-      absl::StrCat("max_concurrent_requests=", max_concurrent_requests));
-  contents.push_back(absl::StrCat("override_host_statuses=",
-                                  override_host_statuses.ToString()));
+  StrAppend(result, ", max_concurrent_requests=");
+  StrAppend(result, std::to_string(max_concurrent_requests));
+  StrAppend(result, ", override_host_statuses=");
+  StrAppend(result, override_host_statuses.ToString());
   if (!metadata.empty()) {
-    contents.push_back(absl::StrCat("metadata={", metadata.ToString(), "}"));
+    StrAppend(result, ", metadata={");
+    StrAppend(result, metadata.ToString());
+    StrAppend(result, "}");
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_cluster.h

@@ -31,7 +31,6 @@
 #include "src/core/xds/xds_client/xds_backend_metric_propagation.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "src/core/xds/xds_client/xds_resource_type_impl.h"
-#include "absl/container/flat_hash_map.h"
 
 namespace grpc_core {
 

data/src/core/xds/grpc/xds_common_types.cc

@@ -17,9 +17,8 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 
 #include "src/core/util/match.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
+#include "src/core/util/string.h"
+#include "absl/strings/match.h"
 
 namespace grpc_core {
 
@@ -29,15 +28,20 @@ namespace grpc_core {
 
 std::string CommonTlsContext::CertificateProviderPluginInstance::ToString()
     const {
-  std::vector<std::string> contents;
+  std::string result = "{";
+  bool is_first = true;
   if (!instance_name.empty()) {
-    contents.push_back(absl::StrFormat("instance_name=%s", instance_name));
+    StrAppend(result, "instance_name=");
+    StrAppend(result, instance_name);
+    is_first = false;
   }
   if (!certificate_name.empty()) {
-    contents.push_back(
-        absl::StrFormat("certificate_name=%s", certificate_name));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "certificate_name=");
+    StrAppend(result, certificate_name);
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 bool CommonTlsContext::CertificateProviderPluginInstance::Empty() const {
@@ -49,26 +53,32 @@ bool CommonTlsContext::CertificateProviderPluginInstance::Empty() const {
 //
 
 std::string CommonTlsContext::CertificateValidationContext::ToString() const {
-  std::vector<std::string> contents;
+  std::string result = "{";
+  bool is_first = true;
   Match(
       ca_certs, [](const std::monostate&) {},
       [&](const CertificateProviderPluginInstance& cert_provider) {
-        contents.push_back(
-            absl::StrCat("ca_certs=cert_provider", cert_provider.ToString()));
+        StrAppend(result, "ca_certs=cert_provider");
+        StrAppend(result, cert_provider.ToString());
+        is_first = false;
       },
       [&](const SystemRootCerts&) {
-        contents.push_back("ca_certs=system_root_certs{}");
+        StrAppend(result, "ca_certs=system_root_certs{}");
+        is_first = false;
       });
   if (!match_subject_alt_names.empty()) {
-    std::vector<std::string> san_matchers;
-    san_matchers.reserve(match_subject_alt_names.size());
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "match_subject_alt_names=[");
+    bool is_first_san = true;
     for (const auto& match : match_subject_alt_names) {
-      san_matchers.push_back(match.ToString());
+      if (!is_first_san) StrAppend(result, ", ");
+      StrAppend(result, match.ToString());
+      is_first_san = false;
     }
-    contents.push_back(absl::StrCat("match_subject_alt_names=[",
-                                    absl::StrJoin(san_matchers, ", "), "]"));
+    StrAppend(result, "]");
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 bool CommonTlsContext::CertificateValidationContext::Empty() const {
@@ -81,18 +91,20 @@ bool CommonTlsContext::CertificateValidationContext::Empty() const {
 //
 
 std::string CommonTlsContext::ToString() const {
-  std::vector<std::string> contents;
+  std::string result = "{";
+  bool is_first = true;
   if (!tls_certificate_provider_instance.Empty()) {
-    contents.push_back(
-        absl::StrFormat("tls_certificate_provider_instance=%s",
-                        tls_certificate_provider_instance.ToString()));
+    StrAppend(result, "tls_certificate_provider_instance=");
+    StrAppend(result, tls_certificate_provider_instance.ToString());
+    is_first = false;
   }
   if (!certificate_validation_context.Empty()) {
-    contents.push_back(
-        absl::StrFormat("certificate_validation_context=%s",
-                        certificate_validation_context.ToString()));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "certificate_validation_context=");
+    StrAppend(result, certificate_validation_context.ToString());
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 bool CommonTlsContext::Empty() const {
@@ -106,6 +118,11 @@ bool CommonTlsContext::Empty() const {
 
 bool HeaderMutationRules::IsMutationAllowed(
     const std::string& header_name) const {
+  // Regardless of the mutation rules, we never allow certain headers.
+  if (absl::StartsWith(header_name, ":") ||
+      absl::StartsWith(header_name, "grpc-") || header_name == "host") {
+    return false;
+  }
   // If true, all header mutations are disallowed, regardless of any other
   // setting.
   if (disallow_all) {
@@ -127,22 +144,30 @@ bool HeaderMutationRules::IsMutationAllowed(
 }
 
 std::string HeaderMutationRules::ToString() const {
-  std::vector<std::string> contents;
+  std::string result = "{";
+  bool is_first = true;
   if (disallow_all) {
-    contents.push_back("disallow_all=true");
+    StrAppend(result, "disallow_all=true");
+    is_first = false;
   }
   if (disallow_is_error) {
-    contents.push_back("disallow_is_error=true");
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "disallow_is_error=true");
+    is_first = false;
   }
   if (allow_expression != nullptr) {
-    contents.push_back(
-        absl::StrCat("allow_expression=", allow_expression->pattern()));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "allow_expression=");
+    StrAppend(result, allow_expression->pattern());
+    is_first = false;
   }
   if (disallow_expression != nullptr) {
-    contents.push_back(
-        absl::StrCat("disallow_expression=", disallow_expression->pattern()));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "disallow_expression=");
+    StrAppend(result, disallow_expression->pattern());
   }
-  return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 }  // namespace grpc_core