grpc 1.65.2 → 1.66.0.pre3

data/src/core/util/latent_see.h

@@ -0,0 +1,214 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_UTIL_LATENT_SEE_H
+#define GRPC_SRC_CORE_UTIL_LATENT_SEE_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_ENABLE_LATENT_SEE
+#include <chrono>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "absl/log/log.h"
+
+#include "src/core/lib/gprpp/per_cpu.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_core {
+namespace latent_see {
+
+struct Metadata {
+  const char* file;
+  int line;
+  const char* name;
+};
+
+enum class EventType : uint8_t { kBegin, kEnd, kFlowStart, kFlowEnd, kMark };
+
+class Log {
+ public:
+  static void FlushThreadLog();
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static void Append(
+      const Metadata* metadata, EventType type, uint64_t id) {
+    thread_events_.push_back(
+        Event{metadata, std::chrono::steady_clock::now(), id, type});
+  }
+
+ private:
+  Log() = default;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Log& Get() {
+    static Log* log = []() {
+      atexit([] {
+        LOG(INFO) << "Writing latent_see.json in " << get_current_dir_name();
+        FILE* f = fopen("latent_see.json", "w");
+        if (f == nullptr) return;
+        fprintf(f, "%s", log->GenerateJson().c_str());
+        fclose(f);
+      });
+      return new Log();
+    }();
+    return *log;
+  }
+
+  std::string GenerateJson();
+
+  struct Event {
+    const Metadata* metadata;
+    std::chrono::steady_clock::time_point timestamp;
+    uint64_t id;
+    EventType type;
+  };
+  struct RecordedEvent {
+    uint64_t thread_id;
+    uint64_t batch_id;
+    Event event;
+  };
+  std::atomic<uint64_t> next_thread_id_{1};
+  std::atomic<uint64_t> next_batch_id_{1};
+  static thread_local std::vector<Event> thread_events_;
+  static thread_local uint64_t thread_id_;
+  struct Fragment {
+    Mutex mu;
+    std::vector<RecordedEvent> events ABSL_GUARDED_BY(mu);
+  };
+  PerCpu<Fragment> fragments_{PerCpuOptions()};
+};
+
+template <bool kFlush>
+class Scope {
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Scope(const Metadata* metadata)
+      : metadata_(metadata) {
+    Log::Append(metadata_, EventType::kBegin, 0);
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Scope() {
+    Log::Append(metadata_, EventType::kEnd, 0);
+    if (kFlush) Log::FlushThreadLog();
+  }
+
+  Scope(const Scope&) = delete;
+  Scope& operator=(const Scope&) = delete;
+
+ private:
+  const Metadata* const metadata_;
+};
+
+using ParentScope = Scope<true>;
+using InnerScope = Scope<false>;
+
+class Flow {
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Flow() : metadata_(nullptr) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Flow(const Metadata* metadata)
+      : metadata_(metadata),
+        id_(next_flow_id_.fetch_add(1, std::memory_order_relaxed)) {
+    Log::Append(metadata_, EventType::kFlowStart, id_);
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Flow() {
+    if (metadata_ != nullptr) {
+      Log::Append(metadata_, EventType::kFlowEnd, id_);
+    }
+  }
+
+  Flow(const Flow&) = delete;
+  Flow& operator=(const Flow&) = delete;
+  Flow(Flow&& other) noexcept
+      : metadata_(std::exchange(other.metadata_, nullptr)), id_(other.id_) {}
+  Flow& operator=(Flow&& other) noexcept {
+    if (metadata_ != nullptr) Log::Append(metadata_, EventType::kFlowEnd, id_);
+    metadata_ = std::exchange(other.metadata_, nullptr);
+    id_ = other.id_;
+    return *this;
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool is_active() const {
+    return metadata_ != nullptr;
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void End() {
+    if (metadata_ == nullptr) return;
+    Log::Append(metadata_, EventType::kFlowEnd, id_);
+    metadata_ = nullptr;
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin(const Metadata* metadata) {
+    if (metadata_ != nullptr) Log::Append(metadata_, EventType::kFlowEnd, id_);
+    metadata_ = metadata;
+    if (metadata_ == nullptr) return;
+    id_ = next_flow_id_.fetch_add(1, std::memory_order_relaxed);
+    Log::Append(metadata_, EventType::kFlowStart, id_);
+  }
+
+ private:
+  const Metadata* metadata_;
+  uint64_t id_;
+  static std::atomic<uint64_t> next_flow_id_;
+};
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline void Mark(const Metadata* md) {
+  Log::Append(md, EventType::kMark, 0);
+}
+
+}  // namespace latent_see
+}  // namespace grpc_core
+#define GRPC_LATENT_SEE_METADATA(name)                                     \
+  []() {                                                                   \
+    static grpc_core::latent_see::Metadata metadata = {__FILE__, __LINE__, \
+                                                       #name};             \
+    return &metadata;                                                      \
+  }()
+// Parent scope: logs a begin and end event, and flushes the thread log on scope
+// exit. Because the flush takes some time it's better to place one parent scope
+// at the top of the stack, and use lighter weight scopes within it.
+#define GRPC_LATENT_SEE_PARENT_SCOPE(name)                       \
+  grpc_core::latent_see::ParentScope latent_see_scope##__LINE__( \
+      GRPC_LATENT_SEE_METADATA(name))
+// Inner scope: logs a begin and end event. Lighter weight than parent scope,
+// but does not flush the thread state - so should only be enclosed by a parent
+// scope.
+#define GRPC_LATENT_SEE_INNER_SCOPE(name)                       \
+  grpc_core::latent_see::InnerScope latent_see_scope##__LINE__( \
+      GRPC_LATENT_SEE_METADATA(name))
+// Mark: logs a single event.
+// This is not flushed automatically, and so should only be used within a parent
+// scope.
+#define GRPC_LATENT_SEE_MARK(name) \
+  grpc_core::latent_see::Mark(GRPC_LATENT_SEE_METADATA(name))
+#else  // !def(GRPC_ENABLE_LATENT_SEE)
+namespace grpc_core {
+namespace latent_see {
+struct Metadata {};
+struct Flow {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool is_active() const { return false; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void End() {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin(Metadata*) {}
+};
+}  // namespace latent_see
+}  // namespace grpc_core
+#define GRPC_LATENT_SEE_METADATA(name) nullptr
+#define GRPC_LATENT_SEE_PARENT_SCOPE(name) \
+  do {                                     \
+  } while (0)
+#define GRPC_LATENT_SEE_INNER_SCOPE(name) \
+  do {                                    \
+  } while (0)
+#define GRPC_LATENT_SEE_MARK(name) \
+  do {                             \
+  } while (0)
+#endif  // GRPC_ENABLE_LATENT_SEE
+
+#endif  // GRPC_SRC_CORE_UTIL_LATENT_SEE_H

data/src/core/util/linux/cpu.cc

@@ -29,8 +29,9 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -41,8 +42,8 @@ static int ncpus = 0;
 static void init_num_cpus() {
 #ifndef GPR_MUSL_LIBC_COMPAT
   if (sched_getcpu() < 0) {
-    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n",
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "Error determining current CPU: "
+               << grpc_core::StrError(errno) << "\n";
     ncpus = 1;
     return;
   }
@@ -51,7 +52,7 @@ static void init_num_cpus() {
   // determined
   ncpus = static_cast<int>(sysconf(_SC_NPROCESSORS_CONF));
   if (ncpus < 1) {
-    gpr_log(GPR_ERROR, "Cannot determine number of CPUs: assuming 1");
+    LOG(ERROR) << "Cannot determine number of CPUs: assuming 1";
     ncpus = 1;
   }
 }
@@ -72,12 +73,12 @@ unsigned gpr_cpu_current_cpu(void) {
   }
   int cpu = sched_getcpu();
   if (cpu < 0) {
-    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n",
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "Error determining current CPU: "
+               << grpc_core::StrError(errno) << "\n";
     return 0;
   }
   if (static_cast<unsigned>(cpu) >= gpr_cpu_num_cores()) {
-    gpr_log(GPR_DEBUG, "Cannot handle hot-plugged CPUs");
+    VLOG(2) << "Cannot handle hot-plugged CPUs";
     return 0;
   }
   return static_cast<unsigned>(cpu);

data/src/core/util/log.cc

@@ -44,23 +44,6 @@ void gpr_unreachable_code(const char* reason, const char* file, int line) {
                    grpc_core::SourceLocation(file, line));
 }
 
-void gpr_assertion_failed(const char* filename, int line, const char* message) {
-  grpc_core::Crash(absl::StrCat("ASSERTION FAILED: ", message),
-                   grpc_core::SourceLocation(filename, line));
-}
-
-const char* gpr_log_severity_string(gpr_log_severity severity) {
-  switch (severity) {
-    case GPR_LOG_SEVERITY_DEBUG:
-      return "D";
-    case GPR_LOG_SEVERITY_INFO:
-      return "I";
-    case GPR_LOG_SEVERITY_ERROR:
-      return "E";
-  }
-  GPR_UNREACHABLE_CODE(return "UNKNOWN");
-}
-
 int gpr_should_log(gpr_log_severity severity) {
   switch (severity) {
     case GPR_LOG_SEVERITY_ERROR:
@@ -130,7 +113,6 @@ void gpr_log_verbosity_init(void) {
   // This setting will change things for other libraries/code that is unrelated
   // to grpc.
   absl::string_view verbosity = grpc_core::ConfigVars::Get().Verbosity();
-  DVLOG(2) << "Log verbosity: " << verbosity;
   if (absl::EqualsIgnoreCase(verbosity, "INFO")) {
     LOG_FIRST_N(WARNING, 1)
         << "Log level INFO is not suitable for production. Prefer WARNING or "

data/src/core/util/posix/cpu.cc

@@ -25,8 +25,9 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -39,7 +40,7 @@ static pthread_key_t thread_id_key;
 static void init_ncpus() {
   ncpus = sysconf(_SC_NPROCESSORS_CONF);
   if (ncpus < 1 || ncpus > INT32_MAX) {
-    gpr_log(GPR_ERROR, "Cannot determine number of CPUs: assuming 1");
+    LOG(ERROR) << "Cannot determine number of CPUs: assuming 1";
     ncpus = 1;
   }
 }

data/src/core/util/posix/tmpfile.cc

@@ -26,9 +26,9 @@
 #include <unistd.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -48,14 +48,14 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
 
   fd = mkstemp(filename_template);
   if (fd == -1) {
-    gpr_log(GPR_ERROR, "mkstemp failed for filename_template %s with error %s.",
-            filename_template, grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "mkstemp failed for filename_template " << filename_template
+               << " with error " << grpc_core::StrError(errno);
     goto end;
   }
   result = fdopen(fd, "w+");
   if (result == nullptr) {
-    gpr_log(GPR_ERROR, "Could not open file %s from fd %d (error = %s).",
-            filename_template, fd, grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "Could not open file " << filename_template << " from fd "
+               << fd << " (error = " << grpc_core::StrError(errno) << ").";
     unlink(filename_template);
     close(fd);
     goto end;

data/src/core/util/time_precise.cc

@@ -25,7 +25,8 @@
 
 #include <algorithm>
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
+
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -72,7 +73,7 @@ static bool is_fake_clock() {
 }
 
 void gpr_precise_clock_init(void) {
-  gpr_log(GPR_DEBUG, "Calibrating timers");
+  VLOG(2) << "Calibrating timers";
 
 #if GPR_LINUX
   if (read_freq_from_kernel(&cycles_per_second)) {
@@ -110,7 +111,7 @@ void gpr_precise_clock_init(void) {
     last_freq = freq;
   }
   cycles_per_second = last_freq;
-  gpr_log(GPR_DEBUG, "... cycles_per_second = %f\n", cycles_per_second);
+  VLOG(2) << "... cycles_per_second = " << cycles_per_second << "\n";
 }
 
 gpr_timespec gpr_cycle_counter_to_time(gpr_cycle_counter cycles) {

data/src/core/{xds/grpc → util}/upb_utils.h

@@ -14,16 +14,14 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_XDS_GRPC_UPB_UTILS_H
-#define GRPC_SRC_CORE_XDS_GRPC_UPB_UTILS_H
+#ifndef GRPC_SRC_CORE_UTIL_UPB_UTILS_H
+#define GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 
 #include <string>
 
 #include "absl/strings/string_view.h"
 #include "upb/base/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
 namespace grpc_core {
 
 // Works for both std::string and absl::string_view.
@@ -42,4 +40,4 @@ inline std::string UpbStringToStdString(const upb_StringView& str) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_XDS_GRPC_UPB_UTILS_H
+#endif  // GRPC_SRC_CORE_UTIL_UPB_UTILS_H

data/src/core/util/useful.h

@@ -23,6 +23,8 @@
 
 #include <cstddef>
 
+#include "absl/log/check.h"
+#include "absl/numeric/bits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 
@@ -37,16 +39,6 @@ T Clamp(T val, T min, T max) {
   return val;
 }
 
-/// rotl, rotr assume x is unsigned
-template <typename T>
-constexpr T RotateLeft(T x, T n) {
-  return ((x << n) | (x >> (sizeof(x) * 8 - n)));
-}
-template <typename T>
-constexpr T RotateRight(T x, T n) {
-  return ((x >> n) | (x << (sizeof(x) * 8 - n)));
-}
-
 // Set the n-th bit of i
 template <typename T>
 T SetBit(T* i, size_t n) {
@@ -65,43 +57,29 @@ bool GetBit(T i, size_t n) {
   return (i & (T(1) << n)) != 0;
 }
 
-namespace useful_detail {
-inline constexpr uint32_t HexdigitBitcount(uint32_t x) {
-  return (x - ((x >> 1) & 0x77777777) - ((x >> 2) & 0x33333333) -
-          ((x >> 3) & 0x11111111));
-}
-}  // namespace useful_detail
-
-inline constexpr uint32_t BitCount(uint32_t i) {
-  return (((useful_detail::HexdigitBitcount(i) +
-            (useful_detail::HexdigitBitcount(i) >> 4)) &
-           0x0f0f0f0f) %
-          255);
-}
-
-inline constexpr uint32_t BitCount(uint64_t i) {
-  return BitCount(static_cast<uint32_t>(i)) +
-         BitCount(static_cast<uint32_t>(i >> 32));
-}
-
-inline constexpr uint32_t BitCount(uint16_t i) {
-  return BitCount(static_cast<uint32_t>(i));
+#if GRPC_HAS_BUILTIN(__builtin_ctz)
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint32_t i) {
+  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
+  return __builtin_ctz(i);
 }
-inline constexpr uint32_t BitCount(uint8_t i) {
-  return BitCount(static_cast<uint32_t>(i));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint64_t i) {
+  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
+  return __builtin_ctzll(i);
 }
-inline constexpr uint32_t BitCount(int64_t i) {
-  return BitCount(static_cast<uint64_t>(i));
+#else
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint32_t i) {
+  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
+  return absl::popcount((i & -i) - 1);
 }
-inline constexpr uint32_t BitCount(int32_t i) {
-  return BitCount(static_cast<uint32_t>(i));
-}
-inline constexpr uint32_t BitCount(int16_t i) {
-  return BitCount(static_cast<uint16_t>(i));
-}
-inline constexpr uint32_t BitCount(int8_t i) {
-  return BitCount(static_cast<uint8_t>(i));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint64_t i) {
+  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
+  return absl::popcount((i & -i) - 1);
 }
+#endif
 
 // This function uses operator< to implement a qsort-style comparison, whereby:
 // if a is smaller than b, a number smaller than 0 is returned.
@@ -163,7 +141,7 @@ inline int64_t SaturatingAdd(int64_t a, int64_t b) {
 }
 
 inline uint32_t MixHash32(uint32_t a, uint32_t b) {
-  return RotateLeft(a, 2u) ^ b;
+  return absl::rotl(a, 2u) ^ b;
 }
 
 inline uint32_t RoundUpToPowerOf2(uint32_t v) {
@@ -177,6 +155,23 @@ inline uint32_t RoundUpToPowerOf2(uint32_t v) {
   return v;
 }
 
+// Return a value with only the lowest bit left on.
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint8_t LowestOneBit(uint8_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint16_t LowestOneBit(uint16_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t LowestOneBit(uint32_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint64_t LowestOneBit(uint64_t x) {
+  return x & -x;
+}
+
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/security/authorization/audit_logging.h"
 #include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_common_types_parser.h"
 
 namespace grpc_core {
 

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

@@ -90,131 +90,6 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::JsonLoader(
   return loader;
 }
 
-//
-// GrpcXdsBootstrap::GrpcXdsServer
-//
-
-namespace {
-
-constexpr absl::string_view kServerFeatureIgnoreResourceDeletion =
-    "ignore_resource_deletion";
-
-}  // namespace
-
-bool GrpcXdsBootstrap::GrpcXdsServer::IgnoreResourceDeletion() const {
-  return server_features_.find(std::string(
-             kServerFeatureIgnoreResourceDeletion)) != server_features_.end();
-}
-
-bool GrpcXdsBootstrap::GrpcXdsServer::Equals(const XdsServer& other) const {
-  const auto& o = static_cast<const GrpcXdsServer&>(other);
-  return (server_uri_ == o.server_uri_ &&
-          channel_creds_config_->type() == o.channel_creds_config_->type() &&
-          channel_creds_config_->Equals(*o.channel_creds_config_) &&
-          server_features_ == o.server_features_);
-}
-
-std::string GrpcXdsBootstrap::GrpcXdsServer::Key() const {
-  return JsonDump(ToJson());
-}
-
-const JsonLoaderInterface* GrpcXdsBootstrap::GrpcXdsServer::JsonLoader(
-    const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<GrpcXdsServer>()
-          .Field("server_uri", &GrpcXdsServer::server_uri_)
-          .Finish();
-  return loader;
-}
-
-namespace {
-
-struct ChannelCreds {
-  std::string type;
-  Json::Object config;
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
-    static const auto* loader =
-        JsonObjectLoader<ChannelCreds>()
-            .Field("type", &ChannelCreds::type)
-            .OptionalField("config", &ChannelCreds::config)
-            .Finish();
-    return loader;
-  }
-};
-
-}  // namespace
-
-void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
-                                                   const JsonArgs& args,
-                                                   ValidationErrors* errors) {
-  // Parse "channel_creds".
-  auto channel_creds_list = LoadJsonObjectField<std::vector<ChannelCreds>>(
-      json.object(), args, "channel_creds", errors);
-  if (channel_creds_list.has_value()) {
-    ValidationErrors::ScopedField field(errors, ".channel_creds");
-    for (size_t i = 0; i < channel_creds_list->size(); ++i) {
-      ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
-      auto& creds = (*channel_creds_list)[i];
-      // Select the first channel creds type that we support, but
-      // validate all entries.
-      if (CoreConfiguration::Get().channel_creds_registry().IsSupported(
-              creds.type)) {
-        ValidationErrors::ScopedField field(errors, ".config");
-        auto config =
-            CoreConfiguration::Get().channel_creds_registry().ParseConfig(
-                creds.type, Json::FromObject(creds.config), args, errors);
-        if (channel_creds_config_ == nullptr) {
-          channel_creds_config_ = std::move(config);
-        }
-      }
-    }
-    if (channel_creds_config_ == nullptr) {
-      errors->AddError("no known creds type found");
-    }
-  }
-  // Parse "server_features".
-  {
-    ValidationErrors::ScopedField field(errors, ".server_features");
-    auto it = json.object().find("server_features");
-    if (it != json.object().end()) {
-      if (it->second.type() != Json::Type::kArray) {
-        errors->AddError("is not an array");
-      } else {
-        const Json::Array& array = it->second.array();
-        for (const Json& feature_json : array) {
-          if (feature_json.type() == Json::Type::kString &&
-              (feature_json.string() == kServerFeatureIgnoreResourceDeletion)) {
-            server_features_.insert(feature_json.string());
-          }
-        }
-      }
-    }
-  }
-}
-
-Json GrpcXdsBootstrap::GrpcXdsServer::ToJson() const {
-  Json::Object channel_creds_json{
-      {"type", Json::FromString(std::string(channel_creds_config_->type()))},
-  };
-  if (channel_creds_config_ != nullptr) {
-    channel_creds_json["config"] = channel_creds_config_->ToJson();
-  }
-  Json::Object json{
-      {"server_uri", Json::FromString(server_uri_)},
-      {"channel_creds",
-       Json::FromArray({Json::FromObject(std::move(channel_creds_json))})},
-  };
-  if (!server_features_.empty()) {
-    Json::Array server_features_json;
-    for (auto& feature : server_features_) {
-      server_features_json.emplace_back(Json::FromString(feature));
-    }
-    json["server_features"] = Json::FromArray(std::move(server_features_json));
-  }
-  return Json::FromObject(std::move(json));
-}
-
 //
 // GrpcXdsBootstrap::GrpcAuthority
 //