grpc 1.80.0 → 1.81.0

data/src/core/util/sorted_pack.h

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
 #include <type_traits>
 
 #include "src/core/util/type_list.h"
@@ -25,63 +26,87 @@ namespace grpc_core {
 
 namespace sorted_pack_detail {
 
-// Find the smallest element of Args, and the rest of the elements
-template <template <typename, typename> class Cmp, typename Args>
-struct Smallest;
-
-template <template <typename, typename> class Cmp, typename Arg,
-          typename... Args>
-struct Smallest<Cmp, Typelist<Arg, Args...>> {
-  using SmallestRest = Smallest<Cmp, Typelist<Args...>>;
-  using PrevSmallest = typename SmallestRest::Result;
-  using PrevRest = typename SmallestRest::Rest;
-  static constexpr bool kCmpResult = Cmp<Arg, PrevSmallest>::kValue;
-  using Result = typename std::conditional<kCmpResult, Arg, PrevSmallest>::type;
-  using Prefix = typename std::conditional<kCmpResult, PrevSmallest, Arg>::type;
-  using Rest = typename PrevRest::template PushFront<Prefix>;
-};
+constexpr bool IsValidAlignment(size_t a) {
+  return a == 64 || a == 32 || a == 16 || a == 8 || a == 4 || a == 2 || a == 1;
+}
 
-template <template <typename, typename> class Cmp, typename Arg>
-struct Smallest<Cmp, Typelist<Arg>> {
-  using Result = Arg;
-  using Rest = Typelist<>;
-};
+template <typename... Ts>
+constexpr bool ValidateAlignments() {
+  return (IsValidAlignment(alignof(Ts)) && ...);
+}
+
+template <typename L1, typename L2>
+struct Concat;
 
-// Sort a list of types into a typelist
-template <template <typename, typename> class Cmp, typename Args>
-struct Sorted;
-
-template <template <typename, typename> class Cmp, typename... Args>
-struct Sorted<Cmp, Typelist<Args...>> {
-  using SmallestResult = Smallest<Cmp, Typelist<Args...>>;
-  using SmallestType = typename SmallestResult::Result;
-  using RestOfTypes = typename SmallestResult::Rest;
-  using SortedRestOfTypes = typename Sorted<Cmp, RestOfTypes>::Result;
-  using Result = typename SortedRestOfTypes::template PushFront<SmallestType>;
+template <typename... T1s, typename... T2s>
+struct Concat<Typelist<T1s...>, Typelist<T2s...>> {
+  using Result = Typelist<T1s..., T2s...>;
 };
 
-template <template <typename, typename> class Cmp, typename Arg>
-struct Sorted<Cmp, Typelist<Arg>> {
-  using Result = Typelist<Arg>;
+// Single-pass MultiPartition minimizes template instantiations to exactly O(N).
+template <typename L64, typename L32, typename L16, typename L8, typename L4,
+          typename L2, typename L1, typename... Ts>
+struct MultiPartition;
+
+template <typename L64, typename L32, typename L16, typename L8, typename L4,
+          typename L2, typename L1, typename T, typename... Rest>
+struct MultiPartition<L64, L32, L16, L8, L4, L2, L1, T, Rest...> {
+  using NextL64 =
+      typename std::conditional<alignof(T) == 64,
+                                typename L64::template PushBack<T>, L64>::type;
+  using NextL32 =
+      typename std::conditional<alignof(T) == 32,
+                                typename L32::template PushBack<T>, L32>::type;
+  using NextL16 =
+      typename std::conditional<alignof(T) == 16,
+                                typename L16::template PushBack<T>, L16>::type;
+  using NextL8 =
+      typename std::conditional<alignof(T) == 8,
+                                typename L8::template PushBack<T>, L8>::type;
+  using NextL4 =
+      typename std::conditional<alignof(T) == 4,
+                                typename L4::template PushBack<T>, L4>::type;
+  using NextL2 =
+      typename std::conditional<alignof(T) == 2,
+                                typename L2::template PushBack<T>, L2>::type;
+  using NextL1 =
+      typename std::conditional<alignof(T) == 1,
+                                typename L1::template PushBack<T>, L1>::type;
+
+  using Result =
+      typename MultiPartition<NextL64, NextL32, NextL16, NextL8, NextL4, NextL2,
+                              NextL1, Rest...>::Result;
 };
 
-template <template <typename, typename> class Cmp>
-struct Sorted<Cmp, Typelist<>> {
-  using Result = Typelist<>;
+template <typename L64, typename L32, typename L16, typename L8, typename L4,
+          typename L2, typename L1>
+struct MultiPartition<L64, L32, L16, L8, L4, L2, L1> {
+  using Result = typename Concat<
+      L64,
+      typename Concat<
+          L32,
+          typename Concat<
+              L16,
+              typename Concat<
+                  L8, typename Concat<L4, typename Concat<L2, L1>::Result>::
+                          Result>::Result>::Result>::Result>::Result;
 };
 
 }  // namespace sorted_pack_detail
 
-// Given a type T<A...>, and a type comparator Cmp<P,Q>, and some set of types
-// Args...:
-// Sort Args... using Cmp into SortedArgs..., then instantiate T<SortedArgs...>
-// as Type.
-// Cmp<P,Q> should have a single constant `kValue` that is true if P < Q.
+// WithSortedPack: A single-pass, exact-alignment bucket sort.
 template <template <typename...> class T,
           template <typename, typename> class Cmp, typename... Args>
 struct WithSortedPack {
-  using Type = typename sorted_pack_detail::Sorted<
-      Cmp, Typelist<Args...>>::Result::template Instantiate<T>;
+  static_assert(sizeof...(Args) == 0 ||
+                    sorted_pack_detail::ValidateAlignments<Args...>(),
+                "Unsupported alignment in WithSortedPack");
+
+  using SortedList = typename sorted_pack_detail::MultiPartition<
+      Typelist<>, Typelist<>, Typelist<>, Typelist<>, Typelist<>, Typelist<>,
+      Typelist<>, Args...>::Result;
+
+  using Type = typename SortedList::template Instantiate<T>;
 };
 
 }  // namespace grpc_core

data/src/core/util/string.cc

@@ -34,6 +34,14 @@
 #include "absl/strings/str_cat.h"
 #include "absl/time/time.h"
 
+namespace grpc_core {
+
+void StrAppend(std::string& dst, absl::string_view s) {
+  absl::StrAppend(&dst, s);
+}
+
+}  // namespace grpc_core
+
 char* gpr_strdup(const char* src) {
   char* dst;
   size_t len;

data/src/core/util/string.h

@@ -26,8 +26,19 @@
 
 #include <string>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
 // String utility functions
 
+namespace grpc_core {
+
+// Simple wrapper for absl::StrAppend() that avoids inlining, which
+// helps avoid binary bloat.
+ABSL_ATTRIBUTE_NOINLINE void StrAppend(std::string& dst, absl::string_view s);
+
+}  // namespace grpc_core
+
 // Flags for gpr_dump function.
 #define GPR_DUMP_HEX 0x00000001
 #define GPR_DUMP_ASCII 0x00000002

data/src/core/util/table.h

@@ -20,6 +20,7 @@
 
 #include <initializer_list>
 #include <new>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 
@@ -29,127 +30,63 @@
 
 namespace grpc_core {
 
-// Meta-programming detail types to aid in building up a Table
 namespace table_detail {
 
-// A tuple-like type that contains manually constructed elements.
-template <typename, typename... Ts>
-struct Elements;
+template <size_t I, typename T, bool IsEmpty = std::is_empty<T>::value>
+struct TableLeaf;
 
-template <typename T, typename... Ts>
-struct Elements<absl::enable_if_t<!std::is_empty<T>::value>, T, Ts...>
-    : Elements<void, Ts...> {
+template <size_t I, typename T>
+struct TableLeaf<I, T, false> {
   struct alignas(T) Data {
     unsigned char bytes[sizeof(T)];
   };
   Data x;
-  Elements() {}
   T* ptr() { return reinterpret_cast<T*>(x.bytes); }
   const T* ptr() const { return reinterpret_cast<const T*>(x.bytes); }
 };
-template <typename T, typename... Ts>
-struct Elements<absl::enable_if_t<std::is_empty<T>::value>, T, Ts...>
-    : Elements<void, Ts...> {
+
+template <size_t I, typename T>
+struct TableLeaf<I, T, true> {
   T* ptr() { return reinterpret_cast<T*>(this); }
   const T* ptr() const { return reinterpret_cast<const T*>(this); }
 };
-template <>
-struct Elements<void> {};
 
-// Element accessor for Elements<>
-// Provides a static method f that returns a pointer to the value of element I
-// for Elements<Ts...>
-template <size_t I, typename... Ts>
-struct GetElem;
+template <typename IndexSequence, typename... Ts>
+struct ElementsImpl;
 
-template <typename T, typename... Ts>
-struct GetElem<0, T, Ts...> {
-  static T* f(Elements<void, T, Ts...>* e) { return e->ptr(); }
-  static const T* f(const Elements<void, T, Ts...>* e) { return e->ptr(); }
+template <size_t... Is, typename... Ts>
+struct ElementsImpl<absl::index_sequence<Is...>, Ts...> : TableLeaf<Is, Ts>... {
 };
 
-template <size_t I, typename T, typename... Ts>
-struct GetElem<I, T, Ts...> {
-  static auto f(Elements<void, T, Ts...>* e)
-      -> decltype(GetElem<I - 1, Ts...>::f(e)) {
-    return GetElem<I - 1, Ts...>::f(e);
-  }
-  static auto f(const Elements<void, T, Ts...>* e)
-      -> decltype(GetElem<I - 1, Ts...>::f(e)) {
-    return GetElem<I - 1, Ts...>::f(e);
-  }
-};
+template <typename... Ts>
+using Elements = ElementsImpl<absl::make_index_sequence<sizeof...(Ts)>, Ts...>;
 
-// CountIncludedStruct is the backing for the CountIncluded function below.
-// Sets a member constant N to the number of times Needle is in Haystack.
-template <typename Needle, typename... Haystack>
-struct CountIncludedStruct;
+template <typename T, size_t I>
+struct IndexedType {};
 
-template <typename Needle, typename Straw, typename... RestOfHaystack>
-struct CountIncludedStruct<Needle, Straw, RestOfHaystack...> {
-  static constexpr size_t N =
-      static_cast<size_t>(std::is_same<Needle, Straw>::value) +
-      CountIncludedStruct<Needle, RestOfHaystack...>::N;
-};
-template <typename Needle>
-struct CountIncludedStruct<Needle> {
-  static constexpr size_t N = 0;
-};
-// Returns the number of times Needle is in Haystack.
-template <typename Needle, typename... Haystack>
-constexpr size_t CountIncluded() {
-  return CountIncludedStruct<Needle, Haystack...>::N;
-}
+template <typename IndexSequence, typename... Ts>
+struct IndexMapImpl;
 
-// IndexOfStruct is the backing for IndexOf below.
-// Set a member constant N to the index of Needle in Haystack.
-// Ignored should be void always, and is used for enable_if_t.
-template <typename Ignored, typename Needle, typename... Haystack>
-struct IndexOfStruct;
-
-template <typename Needle, typename Straw, typename... RestOfHaystack>
-struct IndexOfStruct<absl::enable_if_t<std::is_same<Needle, Straw>::value>,
-                     Needle, Straw, RestOfHaystack...> {
-  // The first element is the one we're looking for. Done.
-  static constexpr size_t N = 0;
-};
-template <typename Needle, typename Straw, typename... RestOfHaystack>
-struct IndexOfStruct<absl::enable_if_t<!std::is_same<Needle, Straw>::value>,
-                     Needle, Straw, RestOfHaystack...> {
-  // The first element is not the one we're looking for, recurse looking at the
-  // tail, and sum the number of recursions.
-  static constexpr size_t N =
-      1 + IndexOfStruct<void, Needle, RestOfHaystack...>::N;
-};
-// Return the index of Needle in Haystack.
-// Guarded by CountIncluded to ensure that the return type is unambiguous.
-// If you got here from a compiler error using Table, it's likely that you've
-// used the type-based accessor/mutators, but the type you're using is repeated
-// more than once in the Table type arguments. Consider either using the indexed
-// accessor/mutator variants, or eliminating the ambiguity in type resolution.
-template <typename Needle, typename... Haystack>
-constexpr absl::enable_if_t<CountIncluded<Needle, Haystack...>() == 1, size_t>
-IndexOf() {
-  return IndexOfStruct<void, Needle, Haystack...>::N;
-}
+template <size_t... Is, typename... Ts>
+struct IndexMapImpl<absl::index_sequence<Is...>, Ts...>
+    : IndexedType<Ts, Is>... {};
 
-// TypeIndexStruct is the backing for TypeIndex below.
-// Sets member type Type to the type at index I in Ts.
-// Implemented as a simple type recursion.
-template <size_t I, typename... Ts>
-struct TypeIndexStruct;
+template <typename... Ts>
+using IndexMap = IndexMapImpl<absl::make_index_sequence<sizeof...(Ts)>, Ts...>;
+
+template <typename T, size_t I>
+constexpr size_t ResolveIndex(IndexedType<T, I>*) {
+  return I;
+}
 
 template <typename T, typename... Ts>
-struct TypeIndexStruct<0, T, Ts...> {
-  using Type = T;
-};
-template <size_t I, typename T, typename... Ts>
-struct TypeIndexStruct<I, T, Ts...> : TypeIndexStruct<I - 1, Ts...> {};
-// TypeIndex is the type at index I in Ts.
+constexpr size_t IndexOf() {
+  return ResolveIndex<T>(static_cast<IndexMap<Ts...>*>(nullptr));
+}
+
 template <size_t I, typename... Ts>
-using TypeIndex = typename TypeIndexStruct<I, Ts...>::Type;
+using TypeIndex = std::tuple_element_t<I, std::tuple<Ts...>>;
 
-// Helper to call the destructor of p if p is non-null.
 template <typename T>
 void DestructIfNotNull(T* p) {
   if (p) p->~T();
@@ -342,10 +279,7 @@ class Table {
   // the default) -- one bit for each type in Ts.
   using PresentBits = BitSet<sizeof...(Ts)>;
   // The tuple-like backing structure for Table.
-  using Elements = table_detail::Elements<void, Ts...>;
-  // Extractor from Elements
-  template <size_t I>
-  using GetElem = table_detail::GetElem<I, Ts...>;
+  using Elements = table_detail::Elements<Ts...>;
 
   // Given a T, return the unambiguous index of it within Ts.
   template <typename T>
@@ -357,14 +291,16 @@ class Table {
   // index I.
   template <size_t I>
   TypeIndex<I>* element_ptr() {
-    return GetElem<I>::f(&elements_);
+    using Leaf = table_detail::TableLeaf<I, TypeIndex<I>>;
+    return static_cast<Leaf*>(&elements_)->ptr();
   }
 
   // Given an index, return a point to the (maybe uninitialized!) data value at
   // index I.
   template <size_t I>
   const TypeIndex<I>* element_ptr() const {
-    return GetElem<I>::f(&elements_);
+    using Leaf = table_detail::TableLeaf<I, TypeIndex<I>>;
+    return static_cast<const Leaf*>(&elements_)->ptr();
   }
 
   // Set the present bit to value (if true - value is present/set, if false,

data/src/core/util/time_precise.cc

@@ -29,6 +29,9 @@
 
 #include "src/core/util/time_precise.h"
 #include "absl/log/log.h"
+#ifdef GPR_CYCLE_COUNTER_CUSTOM
+#include "absl/base/internal/cycleclock.h"
+#endif  // GPR_CYCLE_COUNTER_CUSTOM
 
 #ifndef GPR_CYCLE_COUNTER_CUSTOM
 #if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64
@@ -164,4 +167,42 @@ gpr_timespec gpr_cycle_counter_sub(gpr_cycle_counter a, gpr_cycle_counter b) {
                       gpr_cycle_counter_to_time(b));
 }
 #endif  // GPR_CYCLE_COUNTER_FALLBACK
-#endif  // !GPR_CYCLE_COUNTER_CUSTOM
+#else   // !defined(GPR_CYCLE_COUNTER_CUSTOM)
+
+static double cycles_per_second = 0;
+static gpr_cycle_counter start_cycle;
+
+gpr_cycle_counter gpr_get_cycle_counter() { return CycleClock::Now(); }
+
+void gpr_precise_clock_init(void) {
+  start_cycle = gpr_get_cycle_counter();
+  cycles_per_second = CycleClock::Frequency();
+}
+
+void gpr_precise_clock_now(gpr_timespec* clk) {
+  int64_t counter = gpr_get_cycle_counter();
+  *clk = gpr_cycle_counter_to_time(counter);
+}
+
+gpr_timespec gpr_cycle_counter_to_time(gpr_cycle_counter cycles) {
+  const double secs =
+      static_cast<double>(cycles - start_cycle) / cycles_per_second;
+  gpr_timespec ts;
+  ts.tv_sec = static_cast<int64_t>(secs);
+  ts.tv_nsec = static_cast<int32_t>(GPR_NS_PER_SEC *
+                                    (secs - static_cast<double>(ts.tv_sec)));
+  ts.clock_type = GPR_CLOCK_PRECISE;
+  return ts;
+}
+
+gpr_timespec gpr_cycle_counter_sub(gpr_cycle_counter a, gpr_cycle_counter b) {
+  const double secs = static_cast<double>(a - b) / cycles_per_second;
+  gpr_timespec ts;
+  ts.tv_sec = static_cast<int64_t>(secs);
+  ts.tv_nsec = static_cast<int32_t>(GPR_NS_PER_SEC *
+                                    (secs - static_cast<double>(ts.tv_sec)));
+  ts.clock_type = GPR_TIMESPAN;
+  return ts;
+}
+
+#endif  // GPR_CYCLE_COUNTER_CUSTOM

data/src/core/util/useful.h

@@ -197,97 +197,6 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint64_t LowestOneBit(uint64_t x) {
   return x & -x;
 }
 
-namespace useful_detail {
-
-// Constexpr implementation of std::log for base e.
-// This is a simple implementation using a Taylor series expansion and may not
-// be as accurate as std::log from <cmath>. It is intended for use in constexpr
-// contexts.
-// It uses the identity log(y) = 2 * atanh((y-1)/(y+1))
-// where atanh(x) = x + x^3/3 + x^5/5 + ...
-constexpr double ConstexprLog(double y) {
-  if (y < 0) {
-    return std::numeric_limits<double>::quiet_NaN();
-  }
-  if (y == 0) {
-    return -std::numeric_limits<double>::infinity();
-  }
-  if (y == 1) {
-    return 0.0;
-  }
-  // Bring y into the range [1, 2) to improve convergence.
-  // log(y) = log(y / 2^k) + k*log(2)
-  int k = 0;
-  while (y > 2.0) {
-    y /= 2.0;
-    k++;
-  }
-  while (y < 1.0) {
-    y *= 2.0;
-    k--;
-  }
-  // Now y is in [1, 2).
-  // x = (y-1)/(y+1) is in [0, 1/3).
-  // The series will converge quickly.
-  double x = (y - 1) / (y + 1);
-  double x2 = x * x;
-  double term = x;
-  double sum = term;
-  for (int i = 1; i < 100; ++i) {
-    term *= x2;
-    double next_sum = sum + term / (2 * i + 1);
-    if (next_sum == sum) break;
-    sum = next_sum;
-  }
-  constexpr double kLog2 = 0.693147180559945309417;
-  return 2 * sum + k * kLog2;
-}
-
-// Constexpr implementation of std::exp.
-// This is a simple implementation using a Taylor series expansion and may not
-// be as accurate as std::exp from <cmath>. It is intended for use in constexpr
-// contexts.
-// It uses exp(x) = 1 + x + x^2/2! + x^3/3! + ...
-// For better convergence, we use range reduction via exp(x) = (exp(x/2))^2.
-constexpr double ConstexprExp(double x) {
-  if (x > 2.0 || x < -2.0) {
-    const double half = ConstexprExp(x / 2.0);
-    return half * half;
-  }
-  double sum = 1.0;
-  double term = 1.0;
-  for (int i = 1; i < 30; ++i) {
-    term *= x / i;
-    double next_sum = sum + term;
-    if (next_sum == sum) break;
-    sum = next_sum;
-  }
-  return sum;
-}
-
-}  // namespace useful_detail
-
-// Constexpr implementation of std::pow.
-// This is a simple implementation and may not be as accurate as std::pow from
-// <cmath>. It is intended for use in constexpr contexts.
-// Fuzztests exist in useful_fuzztest.cc to test that the constexpr and
-// non-constexpr implementations are within an acceptable error bound.
-// Replace with std::pow when we move to C++26.
-constexpr double ConstexprPow(double base, double exponent) {
-  // For simplicity, only handle non-negative bases.
-  // std::pow has more complex rules for negative bases.
-  if (base < 0) return std::numeric_limits<double>::quiet_NaN();
-  if (base == 0) {
-    if (exponent > 0) return 0.0;
-    if (exponent == 0) return 1.0;
-    return std::numeric_limits<double>::infinity();
-  }
-  if (exponent == 0.0) return 1.0;
-  if (exponent == 1.0) return base;
-  return useful_detail::ConstexprExp(exponent *
-                                     useful_detail::ConstexprLog(base));
-}
-
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))

data/src/core/util/windows/string_util.cc

@@ -22,8 +22,6 @@
 
 #ifdef GPR_WINDOWS
 
-// Some platforms (namely msys) need wchar to be included BEFORE
-// anything else, especially strsafe.h.
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 #include <grpc/support/string_util.h>
@@ -32,6 +30,10 @@
 #include <stdio.h>
 #include <string.h>
 #include <strsafe.h>
+// The conflict is specific to Windows because the StrCat macro that causes the
+// issue is defined in the strsafe.h header file, which is part of the Windows
+// SDK and is only included when compiling for Windows.
+#undef StrCat
 #include <wchar.h>
 
 #include "src/core/util/string.h"

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

@@ -29,9 +29,8 @@
 #include "src/core/credentials/transport/tls/grpc_tls_certificate_provider.h"
 #include "src/core/util/down_cast.h"
 #include "src/core/util/env.h"
+#include "src/core/util/string.h"
 #include "absl/log/log.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 
 namespace grpc_core {
 
@@ -58,27 +57,40 @@ absl::string_view FileWatcherCertificateProviderFactory::Config::name() const {
 }
 
 std::string FileWatcherCertificateProviderFactory::Config::ToString() const {
-  std::vector<std::string> parts;
-  parts.push_back("{");
+  std::string result = "{";
+  bool is_first = true;
   if (!identity_cert_file_.empty()) {
-    parts.push_back(
-        absl::StrFormat("certificate_file=\"%s\", ", identity_cert_file_));
+    StrAppend(result, "certificate_file=\"");
+    StrAppend(result, identity_cert_file_);
+    StrAppend(result, "\"");
+    is_first = false;
   }
   if (!private_key_file_.empty()) {
-    parts.push_back(
-        absl::StrFormat("private_key_file=\"%s\", ", private_key_file_));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "private_key_file=\"");
+    StrAppend(result, private_key_file_);
+    StrAppend(result, "\"");
+    is_first = false;
   }
   if (!root_cert_file_.empty()) {
-    parts.push_back(
-        absl::StrFormat("ca_certificate_file=\"%s\", ", root_cert_file_));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "ca_certificate_file=\"");
+    StrAppend(result, root_cert_file_);
+    StrAppend(result, "\"");
+    is_first = false;
   }
   if (!spiffe_bundle_map_file_.empty()) {
-    parts.push_back(absl::StrFormat("spiffe_bundle_map_file=\"%s\", ",
-                                    spiffe_bundle_map_file_));
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, "spiffe_bundle_map_file=\"");
+    StrAppend(result, spiffe_bundle_map_file_);
+    StrAppend(result, "\"");
+    is_first = false;
   }
-  parts.push_back(
-      absl::StrFormat("refresh_interval=%ldms}", refresh_interval_.millis()));
-  return absl::StrJoin(parts, "");
+  if (!is_first) StrAppend(result, ", ");
+  StrAppend(result, "refresh_interval=");
+  StrAppend(result, absl::StrCat(refresh_interval_.millis()));
+  StrAppend(result, "ms}");
+  return result;
 }
 
 const JsonLoaderInterface*