grpc 1.50.0 → 1.56.0

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

@@ -40,15 +40,14 @@
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/timestamp.upb.h"
 #include "google/rpc/status.upb.h"
-#include "upb/def.h"
-#include "upb/text_encode.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
+#include "upb/reflection/def.h"
+#include "upb/text/encode.h"
 #include "upb/upb.hpp"
 
-#include <grpc/grpc.h>
-#include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_client.h"
@@ -58,40 +57,15 @@
 
 namespace grpc_core {
 
-// If gRPC is built with -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="...", that string
-// will be appended to the user agent name reported to the xDS server.
-#ifdef GRPC_XDS_USER_AGENT_NAME_SUFFIX
-#define GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING \
-  " " GRPC_XDS_USER_AGENT_NAME_SUFFIX
-#else
-#define GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING ""
-#endif
-
-// If gRPC is built with -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="...", that string
-// will be appended to the user agent version reported to the xDS server.
-#ifdef GRPC_XDS_USER_AGENT_VERSION_SUFFIX
-#define GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING \
-  " " GRPC_XDS_USER_AGENT_VERSION_SUFFIX
-#else
-#define GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING ""
-#endif
-
 XdsApi::XdsApi(XdsClient* client, TraceFlag* tracer,
-               const XdsBootstrap::Node* node, upb::SymbolTable* symtab)
+               const XdsBootstrap::Node* node, upb::SymbolTable* symtab,
+               std::string user_agent_name, std::string user_agent_version)
     : client_(client),
       tracer_(tracer),
       node_(node),
       symtab_(symtab),
-      build_version_(absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING, " ",
-                                  grpc_version_string(),
-                                  GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING,
-                                  GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING)),
-      user_agent_name_(absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING,
-                                    GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING)),
-      user_agent_version_(
-          absl::StrCat("C-core ", grpc_version_string(),
-                       GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING,
-                       GRPC_XDS_USER_AGENT_VERSION_SUFFIX_STRING)) {}
+      user_agent_name_(std::move(user_agent_name)),
+      user_agent_version_(std::move(user_agent_version)) {}
 
 namespace {
 
@@ -100,7 +74,6 @@ struct XdsApiContext {
   TraceFlag* tracer;
   upb_DefPool* symtab;
   upb_Arena* arena;
-  bool use_v3;
 };
 
 void PopulateMetadataValue(const XdsApiContext& context,
@@ -130,73 +103,36 @@ void PopulateMetadata(const XdsApiContext& context,
 void PopulateMetadataValue(const XdsApiContext& context,
                            google_protobuf_Value* value_pb, const Json& value) {
   switch (value.type()) {
-    case Json::Type::JSON_NULL:
+    case Json::Type::kNull:
       google_protobuf_Value_set_null_value(value_pb, 0);
       break;
-    case Json::Type::NUMBER:
+    case Json::Type::kNumber:
       google_protobuf_Value_set_number_value(
-          value_pb, strtod(value.string_value().c_str(), nullptr));
+          value_pb, strtod(value.string().c_str(), nullptr));
       break;
-    case Json::Type::STRING:
+    case Json::Type::kString:
       google_protobuf_Value_set_string_value(
-          value_pb, StdStringToUpbString(value.string_value()));
-      break;
-    case Json::Type::JSON_TRUE:
-      google_protobuf_Value_set_bool_value(value_pb, true);
+          value_pb, StdStringToUpbString(value.string()));
       break;
-    case Json::Type::JSON_FALSE:
-      google_protobuf_Value_set_bool_value(value_pb, false);
+    case Json::Type::kBoolean:
+      google_protobuf_Value_set_bool_value(value_pb, value.boolean());
       break;
-    case Json::Type::OBJECT: {
+    case Json::Type::kObject: {
       google_protobuf_Struct* struct_value =
           google_protobuf_Value_mutable_struct_value(value_pb, context.arena);
-      PopulateMetadata(context, struct_value, value.object_value());
+      PopulateMetadata(context, struct_value, value.object());
       break;
     }
-    case Json::Type::ARRAY: {
+    case Json::Type::kArray: {
       google_protobuf_ListValue* list_value =
           google_protobuf_Value_mutable_list_value(value_pb, context.arena);
-      PopulateListValue(context, list_value, value.array_value());
+      PopulateListValue(context, list_value, value.array());
       break;
     }
   }
 }
 
-// Helper functions to manually do protobuf string encoding, so that we
-// can populate the node build_version field that was removed in v3.
-std::string EncodeVarint(uint64_t val) {
-  std::string data;
-  do {
-    uint8_t byte = val & 0x7fU;
-    val >>= 7;
-    if (val) byte |= 0x80U;
-    data += byte;
-  } while (val);
-  return data;
-}
-std::string EncodeTag(uint32_t field_number, uint8_t wire_type) {
-  return EncodeVarint((field_number << 3) | wire_type);
-}
-std::string EncodeStringField(uint32_t field_number, const std::string& str) {
-  static const uint8_t kDelimitedWireType = 2;
-  return EncodeTag(field_number, kDelimitedWireType) +
-         EncodeVarint(str.size()) + str;
-}
-
-void PopulateBuildVersion(const XdsApiContext& context,
-                          envoy_config_core_v3_Node* node_msg,
-                          const std::string& build_version) {
-  std::string encoded_build_version = EncodeStringField(5, build_version);
-  // TODO(roth): This should use upb_Message_AddUnknown(), but that API is
-  // broken in the current version of upb, so we're using the internal
-  // API for now.  Change this once we upgrade to a version of upb that
-  // fixes this bug.
-  _upb_Message_AddUnknown(node_msg, encoded_build_version.data(),
-                          encoded_build_version.size(), context.arena);
-}
-
 void PopulateNode(const XdsApiContext& context, const XdsBootstrap::Node* node,
-                  const std::string& build_version,
                   const std::string& user_agent_name,
                   const std::string& user_agent_version,
                   envoy_config_core_v3_Node* node_msg) {
@@ -232,9 +168,6 @@ void PopulateNode(const XdsApiContext& context, const XdsBootstrap::Node* node,
       }
     }
   }
-  if (!context.use_v3) {
-    PopulateBuildVersion(context, node_msg, build_version);
-  }
   envoy_config_core_v3_Node_set_user_agent_name(
       node_msg, StdStringToUpbString(user_agent_name));
   envoy_config_core_v3_Node_set_user_agent_version(
@@ -271,13 +204,11 @@ std::string SerializeDiscoveryRequest(
 }  // namespace
 
 std::string XdsApi::CreateAdsRequest(
-    const XdsBootstrap::XdsServer& server, absl::string_view type_url,
-    absl::string_view version, absl::string_view nonce,
-    const std::vector<std::string>& resource_names, absl::Status status,
-    bool populate_node) {
+    absl::string_view type_url, absl::string_view version,
+    absl::string_view nonce, const std::vector<std::string>& resource_names,
+    absl::Status status, bool populate_node) {
   upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr(),
-                                 server.ShouldUseV3()};
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
   // Create a request.
   envoy_service_discovery_v3_DiscoveryRequest* request =
       envoy_service_discovery_v3_DiscoveryRequest_new(arena.ptr());
@@ -317,8 +248,8 @@ std::string XdsApi::CreateAdsRequest(
     envoy_config_core_v3_Node* node_msg =
         envoy_service_discovery_v3_DiscoveryRequest_mutable_node(request,
                                                                  arena.ptr());
-    PopulateNode(context, node_, build_version_, user_agent_name_,
-                 user_agent_version_, node_msg);
+    PopulateNode(context, node_, user_agent_name_, user_agent_version_,
+                 node_msg);
     envoy_config_core_v3_Node_add_client_features(
         node_msg, upb_StringView_FromString("xds.config.resource-in-sotw"),
         context.arena);
@@ -350,12 +281,10 @@ void MaybeLogDiscoveryResponse(
 
 }  // namespace
 
-absl::Status XdsApi::ParseAdsResponse(const XdsBootstrap::XdsServer& server,
-                                      absl::string_view encoded_response,
+absl::Status XdsApi::ParseAdsResponse(absl::string_view encoded_response,
                                       AdsResponseParserInterface* parser) {
   upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr(),
-                                 server.ShouldUseV3()};
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
   // Decode the response.
   const envoy_service_discovery_v3_DiscoveryResponse* response =
       envoy_service_discovery_v3_DiscoveryResponse_parse(
@@ -391,16 +320,21 @@ absl::Status XdsApi::ParseAdsResponse(const XdsBootstrap::XdsServer& server,
         UpbStringToAbsl(google_protobuf_Any_value(resources[i]));
     // Unwrap Resource messages, if so wrapped.
     absl::string_view resource_name;
-    if (type_url == "envoy.api.v2.Resource" ||
-        type_url == "envoy.service.discovery.v3.Resource") {
+    if (type_url == "envoy.service.discovery.v3.Resource") {
       const auto* resource_wrapper = envoy_service_discovery_v3_Resource_parse(
           serialized_resource.data(), serialized_resource.size(), arena.ptr());
       if (resource_wrapper == nullptr) {
-        parser->ResourceWrapperParsingFailed(i);
+        parser->ResourceWrapperParsingFailed(
+            i, "Can't decode Resource proto wrapper");
         continue;
       }
       const auto* resource =
           envoy_service_discovery_v3_Resource_resource(resource_wrapper);
+      if (resource == nullptr) {
+        parser->ResourceWrapperParsingFailed(
+            i, "No resource present in Resource proto wrapper");
+        continue;
+      }
       type_url = absl::StripPrefix(
           UpbStringToAbsl(google_protobuf_Any_type_url(resource)),
           "type.googleapis.com/");
@@ -442,11 +376,9 @@ std::string SerializeLrsRequest(
 
 }  // namespace
 
-std::string XdsApi::CreateLrsInitialRequest(
-    const XdsBootstrap::XdsServer& server) {
+std::string XdsApi::CreateLrsInitialRequest() {
   upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr(),
-                                 server.ShouldUseV3()};
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
   // Create a request.
   envoy_service_load_stats_v3_LoadStatsRequest* request =
       envoy_service_load_stats_v3_LoadStatsRequest_new(arena.ptr());
@@ -454,8 +386,7 @@ std::string XdsApi::CreateLrsInitialRequest(
   envoy_config_core_v3_Node* node_msg =
       envoy_service_load_stats_v3_LoadStatsRequest_mutable_node(request,
                                                                 arena.ptr());
-  PopulateNode(context, node_, build_version_, user_agent_name_,
-               user_agent_version_, node_msg);
+  PopulateNode(context, node_, user_agent_name_, user_agent_version_, node_msg);
   envoy_config_core_v3_Node_add_client_features(
       node_msg,
       upb_StringView_FromString("envoy.lrs.supports_send_all_clusters"),
@@ -517,8 +448,7 @@ void LocalityStatsPopulate(
 std::string XdsApi::CreateLrsRequest(
     ClusterLoadReportMap cluster_load_report_map) {
   upb::Arena arena;
-  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr(),
-                                 /*use_v3=*/false};
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
   // Create a request.
   envoy_service_load_stats_v3_LoadStatsRequest* request =
       envoy_service_load_stats_v3_LoadStatsRequest_new(arena.ptr());
@@ -577,6 +507,24 @@ std::string XdsApi::CreateLrsRequest(
   return SerializeLrsRequest(context, request);
 }
 
+namespace {
+
+void MaybeLogLrsResponse(
+    const XdsApiContext& context,
+    const envoy_service_load_stats_v3_LoadStatsResponse* response) {
+  if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    const upb_MessageDef* msg_type =
+        envoy_service_load_stats_v3_LoadStatsResponse_getmsgdef(context.symtab);
+    char buf[10240];
+    upb_TextEncode(response, msg_type, nullptr, 0, buf, sizeof(buf));
+    gpr_log(GPR_DEBUG, "[xds_client %p] received LRS response: %s",
+            context.client, buf);
+  }
+}
+
+}  // namespace
+
 absl::Status XdsApi::ParseLrsResponse(absl::string_view encoded_response,
                                       bool* send_all_clusters,
                                       std::set<std::string>* cluster_names,
@@ -590,6 +538,8 @@ absl::Status XdsApi::ParseLrsResponse(absl::string_view encoded_response,
   if (decoded_response == nullptr) {
     return absl::UnavailableError("Can't decode response.");
   }
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
+  MaybeLogLrsResponse(context, decoded_response);
   // Check send_all_clusters.
   if (envoy_service_load_stats_v3_LoadStatsResponse_send_all_clusters(
           decoded_response)) {
@@ -636,10 +586,8 @@ std::string XdsApi::AssembleClientConfig(
   // Fill-in the node information
   auto* node = envoy_service_status_v3_ClientConfig_mutable_node(client_config,
                                                                  arena.ptr());
-  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr(),
-                                 /*use_v3=*/true};
-  PopulateNode(context, node_, build_version_, user_agent_name_,
-               user_agent_version_, node);
+  const XdsApiContext context = {client_, tracer_, symtab_->ptr(), arena.ptr()};
+  PopulateNode(context, node_, user_agent_name_, user_agent_version_, node);
   // Dump each resource.
   std::vector<std::string> type_url_storage;
   for (const auto& p : resource_type_metadata_map) {

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_XDS_XDS_API_H
-#define GRPC_CORE_EXT_XDS_XDS_API_H
+#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_API_H
+#define GRPC_SRC_CORE_EXT_XDS_XDS_API_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,8 +30,8 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "envoy/admin/v3/config_dump_shared.upb.h"
-#include "upb/arena.h"
-#include "upb/def.hpp"
+#include "upb/mem/arena.h"
+#include "upb/reflection/def.hpp"
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
@@ -75,8 +75,9 @@ class XdsApi {
                                absl::string_view serialized_resource) = 0;
 
     // Called when a resource is wrapped in a Resource wrapper proto but
-    // we fail to deserialize the wrapper proto.
-    virtual void ResourceWrapperParsingFailed(size_t idx) = 0;
+    // we fail to parse the Resource wrapper.
+    virtual void ResourceWrapperParsingFailed(size_t idx,
+                                              absl::string_view message) = 0;
   };
 
   struct ClusterLoadReport {
@@ -147,12 +148,11 @@ class XdsApi {
                 "");
 
   XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node,
-         upb::SymbolTable* symtab);
+         upb::SymbolTable* symtab, std::string user_agent_name,
+         std::string user_agent_version);
 
   // Creates an ADS request.
-  // Takes ownership of \a error.
-  std::string CreateAdsRequest(const XdsBootstrap::XdsServer& server,
-                               absl::string_view type_url,
+  std::string CreateAdsRequest(absl::string_view type_url,
                                absl::string_view version,
                                absl::string_view nonce,
                                const std::vector<std::string>& resource_names,
@@ -160,12 +160,11 @@ class XdsApi {
 
   // Returns non-OK when failing to deserialize response message.
   // Otherwise, all events are reported to the parser.
-  absl::Status ParseAdsResponse(const XdsBootstrap::XdsServer& server,
-                                absl::string_view encoded_response,
+  absl::Status ParseAdsResponse(absl::string_view encoded_response,
                                 AdsResponseParserInterface* parser);
 
   // Creates an initial LRS request.
-  std::string CreateLrsInitialRequest(const XdsBootstrap::XdsServer& server);
+  std::string CreateLrsInitialRequest();
 
   // Creates an LRS request sending a client-side load report.
   std::string CreateLrsRequest(ClusterLoadReportMap cluster_load_report_map);
@@ -186,11 +185,10 @@ class XdsApi {
   TraceFlag* tracer_;
   const XdsBootstrap::Node* node_;  // Do not own.
   upb::SymbolTable* symtab_;        // Do not own.
-  const std::string build_version_;
   const std::string user_agent_name_;
   const std::string user_agent_version_;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_XDS_XDS_API_H
+#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_API_H

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

@@ -0,0 +1,122 @@
+//
+// Copyright 2023 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/xds/xds_audit_logger_registry.h"
+
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "envoy/config/core/v3/extension.upb.h"
+#include "envoy/config/rbac/v3/rbac.upb.h"
+
+#include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/lib/gprpp/match.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/security/authorization/audit_logging.h"
+
+namespace grpc_core {
+
+namespace {
+
+using experimental::AuditLoggerRegistry;
+
+class StdoutLoggerConfigFactory : public XdsAuditLoggerRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsAuditLoggerConfig(
+      const XdsResourceType::DecodeContext& /*context*/,
+      absl::string_view /*configuration*/,
+      ValidationErrors* /*errors*/) override {
+    // Stdout logger has no configuration right now. So we don't process the
+    // config protobuf.
+    return {};
+  }
+
+  absl::string_view type() override { return Type(); }
+  absl::string_view name() override { return "stdout_logger"; }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.rbac.audit_loggers.stream.v3.StdoutAuditLog";
+  }
+};
+
+}  // namespace
+
+XdsAuditLoggerRegistry::XdsAuditLoggerRegistry() {
+  audit_logger_config_factories_.emplace(
+      StdoutLoggerConfigFactory::Type(),
+      std::make_unique<StdoutLoggerConfigFactory>());
+}
+
+Json XdsAuditLoggerRegistry::ConvertXdsAuditLoggerConfig(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig*
+        logger_config,
+    ValidationErrors* errors) const {
+  const auto* typed_extension_config =
+      envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig_audit_logger(
+          logger_config);
+  ValidationErrors::ScopedField field(errors, ".audit_logger");
+  if (typed_extension_config == nullptr) {
+    errors->AddError("field not present");
+    return Json();  // A null Json object.
+  }
+  ValidationErrors::ScopedField field2(errors, ".typed_config");
+  const auto* typed_config =
+      envoy_config_core_v3_TypedExtensionConfig_typed_config(
+          typed_extension_config);
+  auto extension = ExtractXdsExtension(context, typed_config, errors);
+  if (!extension.has_value()) return Json();
+  absl::string_view name;
+  Json config;
+  Match(
+      extension->value,
+      // Built-in logger types.
+      [&](absl::string_view serialized_value) {
+        auto it = audit_logger_config_factories_.find(extension->type);
+        if (it == audit_logger_config_factories_.end()) return;
+        name = it->second->name();
+        config = Json::FromObject(it->second->ConvertXdsAuditLoggerConfig(
+            context, serialized_value, errors));
+      },
+      // Custom logger types.
+      [&](Json json) {
+        if (!AuditLoggerRegistry::FactoryExists(extension->type)) return;
+        name = extension->type;
+        config = json;
+      });
+  // Config not found in either case if name is empty.
+  if (name.empty()) {
+    if (!envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig_is_optional(
+            logger_config)) {
+      errors->AddError("unsupported audit logger type");
+    }
+    return Json();
+  }
+  // Validate the converted config.
+  auto result = AuditLoggerRegistry::ParseConfig(name, config);
+  if (!result.ok()) {
+    errors->AddError(result.status().message());
+    return Json();
+  }
+  return Json::FromObject({{std::string(name), std::move(config)}});
+}
+}  // namespace grpc_core

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

@@ -0,0 +1,68 @@
+//
+// Copyright 2023 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_EXT_XDS_XDS_AUDIT_LOGGER_REGISTRY_H
+#define GRPC_SRC_CORE_EXT_XDS_XDS_AUDIT_LOGGER_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <map>
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "envoy/config/rbac/v3/rbac.upb.h"
+
+#include "src/core/ext/xds/xds_resource_type.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// A registry that maintains a set of converters that are able to map xDS
+// RBAC audit logger configuration to gRPC's JSON format.
+class XdsAuditLoggerRegistry {
+ public:
+  class ConfigFactory {
+   public:
+    virtual ~ConfigFactory() = default;
+    virtual Json::Object ConvertXdsAuditLoggerConfig(
+        const XdsResourceType::DecodeContext& context,
+        absl::string_view configuration, ValidationErrors* errors) = 0;
+    // The full proto message name for the logger config.
+    virtual absl::string_view type() = 0;
+    // The logger name used for the gRPC registry.
+    virtual absl::string_view name() = 0;
+  };
+
+  XdsAuditLoggerRegistry();
+
+  Json ConvertXdsAuditLoggerConfig(
+      const XdsResourceType::DecodeContext& context,
+      const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig*
+          logger_config,
+      ValidationErrors* errors) const;
+
+ private:
+  // A map of config factories that goes from the type of the audit logging
+  // config to the config factory.
+  std::map<absl::string_view /* Owned by ConfigFactory */,
+           std::unique_ptr<ConfigFactory>>
+      audit_logger_config_factories_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_AUDIT_LOGGER_REGISTRY_H

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

@@ -25,11 +25,11 @@
 
 namespace grpc_core {
 
-// TODO(donnadionne): check to see if federation is enabled, this will be
-// removed once federation is fully integrated and enabled by default.
+// TODO(roth,apolcyn): remove this federation env var after the 1.55
+// release.
 bool XdsFederationEnabled() {
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_FEDERATION");
-  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;

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

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
-#define GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
+#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
+#define GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -46,7 +46,6 @@ class XdsBootstrap {
     virtual ~XdsServer() = default;
 
     virtual const std::string& server_uri() const = 0;
-    virtual bool ShouldUseV3() const = 0;
     virtual bool IgnoreResourceDeletion() const = 0;
 
     virtual bool Equals(const XdsServer& other) const = 0;
@@ -86,4 +85,4 @@ class XdsBootstrap {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
+#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_BOOTSTRAP_H