grpc 1.55.3 → 1.56.0.pre3

data/src/core/ext/xds/xds_http_stateful_session_filter.h

@@ -48,7 +48,8 @@ class XdsHttpStatefulSessionFilter : public XdsHttpFilterImpl {
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override) const override;
+      const FilterConfig* filter_config_override,
+      absl::string_view filter_name) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -33,6 +33,8 @@
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 
+#include <grpc/support/json.h>
+
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
@@ -51,7 +53,7 @@ class RoundRobinLbPolicyConfigFactory
       const XdsResourceType::DecodeContext& /*context*/,
       absl::string_view /*configuration*/, ValidationErrors* /*errors*/,
       int /*recursion_depth*/) override {
-    return Json::Object{{"round_robin", Json::Object()}};
+    return Json::Object{{"round_robin", Json::FromObject({})}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -84,7 +86,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
             resource);
     if (enable_oob_load_report != nullptr &&
         google_protobuf_BoolValue_value(enable_oob_load_report)) {
-      config["enableOobLoadReport"] = true;
+      config["enableOobLoadReport"] = Json::FromBool(true);
     }
     // oob_reporting_period
     auto* duration_proto =
@@ -93,7 +95,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".oob_reporting_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["oobReportingPeriod"] = duration.ToJsonString();
+      config["oobReportingPeriod"] = Json::FromString(duration.ToJsonString());
     }
     // blackout_period
     duration_proto =
@@ -102,7 +104,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".blackout_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["blackoutPeriod"] = duration.ToJsonString();
+      config["blackoutPeriod"] = Json::FromString(duration.ToJsonString());
     }
     // weight_update_period
     duration_proto =
@@ -111,7 +113,7 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".weight_update_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["weightUpdatePeriod"] = duration.ToJsonString();
+      config["weightUpdatePeriod"] = Json::FromString(duration.ToJsonString());
     }
     // weight_expiration_period
     duration_proto =
@@ -120,7 +122,8 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
     if (duration_proto != nullptr) {
       ValidationErrors::ScopedField field(errors, ".weight_expiration_period");
       Duration duration = ParseDuration(duration_proto, errors);
-      config["weightExpirationPeriod"] = duration.ToJsonString();
+      config["weightExpirationPeriod"] =
+          Json::FromString(duration.ToJsonString());
     }
     // error_utilization_penalty
     auto* error_utilization_penalty =
@@ -133,9 +136,10 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
       if (value < 0.0) {
         errors->AddError("value must be non-negative");
       }
-      config["errorUtilizationPenalty"] = value;
+      config["errorUtilizationPenalty"] = Json::FromNumber(value);
     }
-    return Json::Object{{"weighted_round_robin", std::move(config)}};
+    return Json::Object{
+        {"weighted_round_robin", Json::FromObject(std::move(config))}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -197,10 +201,10 @@ class RingHashLbPolicyConfigFactory
     }
     return Json::Object{
         {"ring_hash_experimental",
-         Json::Object{
-             {"minRingSize", min_ring_size},
-             {"maxRingSize", max_ring_size},
-         }},
+         Json::FromObject({
+             {"minRingSize", Json::FromNumber(min_ring_size)},
+             {"maxRingSize", Json::FromNumber(max_ring_size)},
+         })},
     };
   }
 
@@ -238,7 +242,8 @@ class WrrLocalityLbPolicyConfigFactory
         context, endpoint_picking_policy, errors, recursion_depth + 1);
     return Json::Object{
         {"xds_wrr_locality_experimental",
-         Json::Object{{"childPolicy", std::move(child_policy)}}}};
+         Json::FromObject(
+             {{"childPolicy", Json::FromArray(std::move(child_policy))}})}};
   }
 
   absl::string_view type() override { return Type(); }
@@ -306,8 +311,9 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     if (serialized_value != nullptr) {
       auto config_factory_it = policy_config_factories_.find(extension->type);
       if (config_factory_it != policy_config_factories_.end()) {
-        return Json::Array{config_factory_it->second->ConvertXdsLbPolicyConfig(
-            this, context, *serialized_value, errors, recursion_depth)};
+        return Json::Array{Json::FromObject(
+            config_factory_it->second->ConvertXdsLbPolicyConfig(
+                this, context, *serialized_value, errors, recursion_depth))};
       }
     }
     // Check for custom LB policy type.
@@ -316,7 +322,7 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
         CoreConfiguration::Get().lb_policy_registry().LoadBalancingPolicyExists(
             extension->type, nullptr)) {
       return Json::Array{
-          Json::Object{{std::string(extension->type), std::move(*json)}}};
+          Json::FromObject({{std::string(extension->type), std::move(*json)}})};
     }
     // Unsupported type.  Continue to next entry.
   }

data/src/core/ext/xds/xds_listener.cc

@@ -37,6 +37,7 @@
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/config/listener/v3/listener_components.upb.h"
+#include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"

data/src/core/ext/xds/xds_route_config.cc

@@ -45,6 +45,7 @@
 #include "envoy/config/route/v3/route.upbdefs.h"
 #include "envoy/config/route/v3/route_components.upb.h"
 #include "envoy/type/matcher/v3/regex.upb.h"
+#include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/percent.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/any.upb.h"
@@ -79,10 +80,10 @@
 
 namespace grpc_core {
 
-// TODO(donnadionne): Remove once RLS is no longer experimental
+// TODO(apolcyn): remove this flag by the 1.58 release
 bool XdsRlsEnabled() {
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_RLS_LB");
-  if (!value.has_value()) return false;
+  if (!value.has_value()) return true;
   bool parsed_value;
   bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
   return parse_succeeded && parsed_value;
@@ -486,6 +487,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
     int64_t range_start = 0;
     int64_t range_end = 0;
     bool present_match = false;
+    bool case_sensitive = true;
     if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
       type = HeaderMatcher::Type::kExact;
       match_string = UpbStringToStdString(
@@ -514,11 +516,46 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
       type = HeaderMatcher::Type::kRange;
       const envoy_type_v3_Int64Range* range_matcher =
           envoy_config_route_v3_HeaderMatcher_range_match(header);
+      GPR_ASSERT(range_matcher != nullptr);
       range_start = envoy_type_v3_Int64Range_start(range_matcher);
       range_end = envoy_type_v3_Int64Range_end(range_matcher);
     } else if (envoy_config_route_v3_HeaderMatcher_has_present_match(header)) {
       type = HeaderMatcher::Type::kPresent;
       present_match = envoy_config_route_v3_HeaderMatcher_present_match(header);
+    } else if (envoy_config_route_v3_HeaderMatcher_has_string_match(header)) {
+      ValidationErrors::ScopedField field(errors, ".string_match");
+      const auto* matcher =
+          envoy_config_route_v3_HeaderMatcher_string_match(header);
+      GPR_ASSERT(matcher != nullptr);
+      if (envoy_type_matcher_v3_StringMatcher_has_exact(matcher)) {
+        type = HeaderMatcher::Type::kExact;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_exact(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_prefix(matcher)) {
+        type = HeaderMatcher::Type::kPrefix;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_prefix(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_suffix(matcher)) {
+        type = HeaderMatcher::Type::kSuffix;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_suffix(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_contains(matcher)) {
+        type = HeaderMatcher::Type::kContains;
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_StringMatcher_contains(matcher));
+      } else if (envoy_type_matcher_v3_StringMatcher_has_safe_regex(matcher)) {
+        type = HeaderMatcher::Type::kSafeRegex;
+        const auto* regex_matcher =
+            envoy_type_matcher_v3_StringMatcher_safe_regex(matcher);
+        GPR_ASSERT(regex_matcher != nullptr);
+        match_string = UpbStringToStdString(
+            envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
+      } else {
+        errors->AddError("invalid string matcher");
+        continue;
+      }
+      case_sensitive =
+          !envoy_type_matcher_v3_StringMatcher_ignore_case(matcher);
     } else {
       errors->AddError("invalid header matcher");
       continue;
@@ -527,7 +564,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
         envoy_config_route_v3_HeaderMatcher_invert_match(header);
     absl::StatusOr<HeaderMatcher> header_matcher =
         HeaderMatcher::Create(name, type, match_string, range_start, range_end,
-                              present_match, invert_match);
+                              present_match, invert_match, case_sensitive);
     if (!header_matcher.ok()) {
       errors->AddError(absl::StrCat("cannot create header matcher: ",
                                     header_matcher.status().message()));

data/src/core/ext/xds/xds_routing.cc

@@ -248,8 +248,8 @@ XdsRouting::GeneratePerHTTPFilterConfigs(
         FindFilterConfigOverride(http_filter.name, vhost, route,
                                  cluster_weight);
     // Generate service config for filter.
-    auto method_config_field =
-        filter_impl->GenerateServiceConfig(http_filter.config, config_override);
+    auto method_config_field = filter_impl->GenerateServiceConfig(
+        http_filter.config, config_override, http_filter.name);
     if (!method_config_field.ok()) {
       return absl::FailedPreconditionError(absl::StrCat(
           "failed to generate method config for HTTP filter ", http_filter.name,

data/src/core/ext/xds/xds_transport_grpc.cc

@@ -47,6 +47,7 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/json/json.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
@@ -255,7 +256,8 @@ grpc_channel* CreateXdsChannel(const ChannelArgs& args,
                                const GrpcXdsBootstrap::GrpcXdsServer& server) {
   RefCountedPtr<grpc_channel_credentials> channel_creds =
       CoreConfiguration::Get().channel_creds_registry().CreateChannelCreds(
-          server.channel_creds_type(), server.channel_creds_config());
+          server.channel_creds_type(),
+          Json::FromObject(server.channel_creds_config()));
   return grpc_channel_create(server.server_uri().c_str(), channel_creds.get(),
                              args.ToC().get());
 }

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

@@ -87,6 +87,11 @@ class AVL {
     return QsortCompare(*this, other) < 0;
   }
 
+  size_t Height() const {
+    if (root_ == nullptr) return 0;
+    return root_->height;
+  }
+
  private:
   struct Node;
 

data/src/core/lib/backoff/random_early_detection.h

@@ -43,11 +43,6 @@ class RandomEarlyDetection {
   uint64_t soft_limit() const { return soft_limit_; }
   uint64_t hard_limit() const { return hard_limit_; }
 
-  void SetLimits(uint64_t soft_limit, uint64_t hard_limit) {
-    soft_limit_ = soft_limit;
-    hard_limit_ = hard_limit;
-  }
-
  private:
   // The soft limit is the size at which we start rejecting items with a
   // probability that increases linearly to 1 as the size approaches the hard

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

@@ -39,6 +39,7 @@
 #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 {
@@ -126,21 +127,55 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
   return result;
 }
 
+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");
+  }
+}
+
+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");
+  }
+}
+
 ChannelArgs::CPtr 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());
-        }));
+    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())));
@@ -178,8 +213,9 @@ ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
 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);
+  const auto* i = v->GetIfInt();
+  if (i == nullptr) return absl::nullopt;
+  return *i;
 }
 
 absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
@@ -195,8 +231,9 @@ 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);
+  const auto* s = v->GetIfString();
+  if (s == nullptr) return absl::nullopt;
+  return *s;
 }
 
 absl::optional<std::string> ChannelArgs::GetOwnedString(
@@ -209,14 +246,15 @@ absl::optional<std::string> ChannelArgs::GetOwnedString(
 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();
+  const auto* pp = v->GetIfPointer();
+  if (pp == nullptr) return nullptr;
+  return pp->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);
+  auto* i = v->GetIfInt();
   if (i == nullptr) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
             std::string(name).c_str());
@@ -238,11 +276,11 @@ 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)) {
+    if (auto* i = value.GetIfInt()) {
       value_str = std::to_string(*i);
-    } else if (auto* s = absl::get_if<std::string>(&value)) {
+    } else if (auto* s = value.GetIfString()) {
       value_str = *s;
-    } else if (auto* p = absl::get_if<Pointer>(&value)) {
+    } else if (auto* p = value.GetIfPointer()) {
       value_str = absl::StrFormat("%p", p->c_pointer());
     }
     arg_strings.push_back(absl::StrCat(key, "=", value_str));
@@ -251,6 +289,26 @@ std::string ChannelArgs::ToString() const {
 }
 
 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);
+    });
+    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);
+      }
+    });
+    return result;
+  }
+}
+
+ChannelArgs ChannelArgs::FuzzingReferenceUnionWith(ChannelArgs other) const {
+  // DO NOT OPTIMIZE THIS!!
   args_.ForEach([&other](const std::string& key, const Value& value) {
     other.args_ = other.args_.Add(key, value);
   });

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

@@ -281,7 +281,35 @@ class ChannelArgs {
     const grpc_arg_pointer_vtable* vtable_;
   };
 
-  using Value = absl::variant<int, std::string, Pointer>;
+  class Value {
+   public:
+    explicit Value(int n) : rep_(n) {}
+    explicit Value(std::string s)
+        : rep_(std::make_shared<const std::string>(std::move(s))) {}
+    explicit Value(Pointer p) : rep_(std::move(p)) {}
+
+    const int* GetIfInt() const { return absl::get_if<int>(&rep_); }
+    const std::string* GetIfString() const {
+      auto* p = absl::get_if<std::shared_ptr<const std::string>>(&rep_);
+      if (p == nullptr) return nullptr;
+      return p->get();
+    }
+    const Pointer* GetIfPointer() const { return absl::get_if<Pointer>(&rep_); }
+
+    grpc_arg MakeCArg(const char* name) const;
+
+    bool operator<(const Value& rhs) const;
+    bool operator==(const Value& rhs) const;
+    bool operator!=(const Value& rhs) const { return !this->operator==(rhs); }
+    bool operator==(absl::string_view rhs) const {
+      auto* p = absl::get_if<std::shared_ptr<const std::string>>(&rep_);
+      if (p == nullptr) return false;
+      return **p == rhs;
+    }
+
+   private:
+    absl::variant<int, std::shared_ptr<const std::string>, Pointer> rep_;
+  };
 
   struct ChannelArgsDeleter {
     void operator()(const grpc_channel_args* p) const;
@@ -307,6 +335,11 @@ class ChannelArgs {
   // If a key is present in both, the value from this is used.
   GRPC_MUST_USE_RESULT ChannelArgs UnionWith(ChannelArgs other) const;
 
+  // Only used in union_with_test.cc, reference version of UnionWith for
+  // differential fuzzing.
+  GRPC_MUST_USE_RESULT ChannelArgs
+  FuzzingReferenceUnionWith(ChannelArgs other) const;
+
   const Value* Get(absl::string_view name) const;
   GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
                                        Pointer value) const;

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

@@ -21,10 +21,12 @@
 #include "src/core/lib/channel/channel_trace.h"
 
 #include <algorithm>
-#include <string>
 #include <utility>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
+#include <grpc/support/json.h>
 
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
@@ -140,21 +142,21 @@ const char* severity_string(ChannelTrace::Severity severity) {
 Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
   char* description = grpc_slice_to_c_string(data_);
   Json::Object object = {
-      {"description", description},
-      {"severity", severity_string(severity_)},
-      {"timestamp", gpr_format_timespec(timestamp_)},
+      {"description", Json::FromString(description)},
+      {"severity", Json::FromString(severity_string(severity_))},
+      {"timestamp", Json::FromString(gpr_format_timespec(timestamp_))},
   };
   gpr_free(description);
   if (referenced_entity_ != nullptr) {
     const bool is_channel =
         (referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
          referenced_entity_->type() == BaseNode::EntityType::kInternalChannel);
-    object[is_channel ? "channelRef" : "subchannelRef"] = Json::Object{
+    object[is_channel ? "channelRef" : "subchannelRef"] = Json::FromObject({
         {(is_channel ? "channelId" : "subchannelId"),
-         std::to_string(referenced_entity_->uuid())},
-    };
+         Json::FromString(absl::StrCat(referenced_entity_->uuid()))},
+    });
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 Json ChannelTrace::RenderJson() const {
@@ -163,10 +165,12 @@ Json ChannelTrace::RenderJson() const {
     return Json();  // JSON null
   }
   Json::Object object = {
-      {"creationTimestamp", gpr_format_timespec(time_created_)},
+      {"creationTimestamp",
+       Json::FromString(gpr_format_timespec(time_created_))},
   };
   if (num_events_logged_ > 0) {
-    object["numEventsLogged"] = std::to_string(num_events_logged_);
+    object["numEventsLogged"] =
+        Json::FromString(absl::StrCat(num_events_logged_));
   }
   // Only add in the event list if it is non-empty.
   if (head_trace_ != nullptr) {
@@ -174,9 +178,9 @@ Json ChannelTrace::RenderJson() const {
     for (TraceEvent* it = head_trace_; it != nullptr; it = it->next()) {
       array.emplace_back(it->RenderTraceEvent());
     }
-    object["events"] = std::move(array);
+    object["events"] = Json::FromArray(std::move(array));
   }
-  return object;
+  return Json::FromObject(std::move(object));
 }
 
 }  // namespace channelz