grpc 1.55.0 → 1.56.0.pre3

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_grpc.cc

@@ -35,6 +35,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/json.h>
+
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/json/json.h"
@@ -139,7 +141,7 @@ void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
           CoreConfiguration::Get().channel_creds_registry().IsSupported(
               creds.type)) {
         if (!CoreConfiguration::Get().channel_creds_registry().IsValidConfig(
-                creds.type, creds.config)) {
+                creds.type, Json::FromObject(creds.config))) {
           errors->AddError(absl::StrCat(
               "invalid config for channel creds type \"", creds.type, "\""));
           continue;
@@ -173,22 +175,25 @@ void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
 }
 
 Json GrpcXdsBootstrap::GrpcXdsServer::ToJson() const {
-  Json::Object channel_creds_json{{"type", channel_creds_.type}};
+  Json::Object channel_creds_json{
+      {"type", Json::FromString(channel_creds_.type)},
+  };
   if (!channel_creds_.config.empty()) {
-    channel_creds_json["config"] = channel_creds_.config;
+    channel_creds_json["config"] = Json::FromObject(channel_creds_.config);
   }
   Json::Object json{
-      {"server_uri", server_uri_},
-      {"channel_creds", Json::Array{std::move(channel_creds_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(feature);
+      server_features_json.emplace_back(Json::FromString(feature));
     }
-    json["server_features"] = std::move(server_features_json);
+    json["server_features"] = Json::FromArray(std::move(server_features_json));
   }
-  return json;
+  return Json::FromObject(std::move(json));
 }
 
 //
@@ -254,6 +259,13 @@ const JsonLoaderInterface* GrpcXdsBootstrap::JsonLoader(const JsonArgs&) {
 void GrpcXdsBootstrap::JsonPostLoad(const Json& /*json*/,
                                     const JsonArgs& /*args*/,
                                     ValidationErrors* errors) {
+  // Verify that there is at least one server present.
+  {
+    ValidationErrors::ScopedField field(errors, ".xds_servers");
+    if (servers_.empty() && !errors->FieldHasErrors()) {
+      errors->AddError("must be non-empty");
+    }
+  }
   // Verify that each authority has the right prefix in the
   // client_listener_resource_name_template field.
   {
@@ -292,7 +304,7 @@ std::string GrpcXdsBootstrap::ToString() const {
                         "},\n",
                         node_->id(), node_->cluster(), node_->locality_region(),
                         node_->locality_zone(), node_->locality_sub_zone(),
-                        JsonDump(Json{node_->metadata()})));
+                        JsonDump(Json::FromObject(node_->metadata()))));
   }
   parts.push_back(
       absl::StrFormat("servers=[\n%s\n],\n", JsonDump(servers_[0].ToJson())));

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

@@ -30,6 +30,7 @@
 #include "absl/types/optional.h"
 
 #include "src/core/ext/xds/certificate_provider_store.h"
+#include "src/core/ext/xds/xds_audit_logger_registry.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_http_filters.h"
@@ -161,6 +162,9 @@ class GrpcXdsBootstrap : public XdsBootstrap {
   const XdsLbPolicyRegistry& lb_policy_registry() const {
     return lb_policy_registry_;
   }
+  const XdsAuditLoggerRegistry& audit_logger_registry() const {
+    return audit_logger_registry_;
+  }
 
   // Exposed for testing purposes only.
   const std::map<std::string, GrpcAuthority>& authorities() const {
@@ -177,6 +181,7 @@ class GrpcXdsBootstrap : public XdsBootstrap {
   XdsHttpFilterRegistry http_filter_registry_;
   XdsClusterSpecifierPluginRegistry cluster_specifier_plugin_registry_;
   XdsLbPolicyRegistry lb_policy_registry_;
+  XdsAuditLoggerRegistry audit_logger_registry_;
 };
 
 }  // namespace grpc_core

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

@@ -152,7 +152,8 @@ class XdsClient::ChannelState::AdsCallState
                        absl::string_view serialized_resource) override
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
-    void ResourceWrapperParsingFailed(size_t idx) override;
+    void ResourceWrapperParsingFailed(size_t idx,
+                                      absl::string_view message) override;
 
     Result TakeResult() { return std::move(result_); }
 
@@ -878,9 +879,9 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
 }
 
 void XdsClient::ChannelState::AdsCallState::AdsResponseParser::
-    ResourceWrapperParsingFailed(size_t idx) {
-  result_.errors.emplace_back(absl::StrCat(
-      "resource index ", idx, ": Can't decode Resource proto wrapper"));
+    ResourceWrapperParsingFailed(size_t idx, absl::string_view message) {
+  result_.errors.emplace_back(
+      absl::StrCat("resource index ", idx, ": ", message));
 }
 
 //

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

@@ -239,7 +239,7 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
-  PerCpu<Stats> stats_{32};
+  PerCpu<Stats> stats_{PerCpuOptions().SetMaxShards(32).SetCpusPerShard(4)};
 };
 
 }  // namespace grpc_core

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

@@ -46,6 +46,7 @@
 #include "upb/base/string_view.h"
 #include "upb/text/encode.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
@@ -102,8 +103,8 @@ std::string XdsClusterResource::ToString() const {
             "prioritized_cluster_names=[",
             absl::StrJoin(aggregate.prioritized_cluster_names, ", "), "]"));
       });
-  contents.push_back(
-      absl::StrCat("lb_policy_config=", JsonDump(Json{lb_policy_config})));
+  contents.push_back(absl::StrCat("lb_policy_config=",
+                                  JsonDump(Json::FromArray(lb_policy_config))));
   if (lrs_load_reporting_server.has_value()) {
     contents.push_back(absl::StrCat("lrs_load_reporting_server_name=",
                                     lrs_load_reporting_server->server_uri()));
@@ -329,7 +330,8 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
     if (original_error_count == errors->size()) {
       auto config = CoreConfiguration::Get()
                         .lb_policy_registry()
-                        .ParseLoadBalancingConfig(cds_update->lb_policy_config);
+                        .ParseLoadBalancingConfig(
+                            Json::FromArray(cds_update->lb_policy_config));
       if (!config.ok()) errors->AddError(config.status().message());
     }
     return;
@@ -339,17 +341,16 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
   if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
       envoy_config_cluster_v3_Cluster_ROUND_ROBIN) {
     cds_update->lb_policy_config = {
-        Json::Object{
+        Json::FromObject({
             {"xds_wrr_locality_experimental",
-             Json::Object{
-                 {"childPolicy",
-                  Json::Array{
-                      Json::Object{
-                          {"round_robin", Json::Object()},
-                      },
-                  }},
-             }},
-        },
+             Json::FromObject({
+                 {"childPolicy", Json::FromArray({
+                                     Json::FromObject({
+                                         {"round_robin", Json::FromObject({})},
+                                     }),
+                                 })},
+             })},
+        }),
     };
   } else if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
              envoy_config_cluster_v3_Cluster_RING_HASH) {
@@ -391,13 +392,13 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
       }
     }
     cds_update->lb_policy_config = {
-        Json::Object{
+        Json::FromObject({
             {"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)},
+             })},
+        }),
     };
   } else {
     ValidationErrors::ScopedField field(errors, ".lb_policy");

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

@@ -30,6 +30,7 @@
 #include "upb/json/encode.h"
 #include "upb/upb.hpp"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/json/json.h"
@@ -91,14 +92,16 @@ Json XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
                  reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
   auto json = JsonParse(reinterpret_cast<char*>(buf));
   GPR_ASSERT(json.ok());
-  return Json::Array{Json::Object{
-      {"rls_experimental",
-       Json::Object{
-           {"routeLookupConfig", std::move(*json)},
-           {"childPolicy",
-            Json::Array{Json::Object{{"cds_experimental", Json::Object()}}}},
-           {"childPolicyConfigTargetFieldName", "cluster"},
-       }}}};
+  return Json::FromArray({Json::FromObject(
+      {{"rls_experimental",
+        Json::FromObject({
+            {"routeLookupConfig", std::move(*json)},
+            {"childPolicy",
+             Json::FromArray({
+                 Json::FromObject({{"cds_experimental", Json::FromObject({})}}),
+             })},
+            {"childPolicyConfigTargetFieldName", Json::FromString("cluster")},
+        })}})});
 }
 
 //

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

@@ -45,6 +45,8 @@
 #include "upb/upb.hpp"
 #include "xds/type/v3/typed_struct.upb.h"
 
+#include <grpc/support/json.h>
+
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
@@ -486,7 +488,7 @@ absl::optional<XdsExtension> ExtractXdsExtension(
         errors, absl::StrCat(".value[", extension.type, "]"));
     auto* protobuf_struct = xds_type_v3_TypedStruct_value(typed_struct);
     if (protobuf_struct == nullptr) {
-      extension.value = Json::Object();  // Default to empty object.
+      extension.value = Json::FromObject({});  // Default to empty object.
     } else {
       auto json = ParseProtobufStructToJson(context, protobuf_struct);
       if (!json.ok()) {

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

@@ -34,6 +34,7 @@
 #include "google/protobuf/wrappers.upb.h"
 
 #include <grpc/status.h>
+#include <grpc/support/json.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 #include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
@@ -139,14 +140,14 @@ XdsHttpFaultFilter::GenerateFilterConfig(
     }
     // Set the abort_code, even if it's OK
     fault_injection_policy_json["abortCode"] =
-        grpc_status_code_to_string(abort_grpc_status_code);
+        Json::FromString(grpc_status_code_to_string(abort_grpc_status_code));
     // Set the headers if we enabled header abort injection control
     if (envoy_extensions_filters_http_fault_v3_FaultAbort_has_header_abort(
             fault_abort)) {
       fault_injection_policy_json["abortCodeHeader"] =
-          "x-envoy-fault-abort-grpc-request";
+          Json::FromString("x-envoy-fault-abort-grpc-request");
       fault_injection_policy_json["abortPercentageHeader"] =
-          "x-envoy-fault-abort-percentage";
+          Json::FromString("x-envoy-fault-abort-percentage");
     }
     // Set the fraction percent
     auto* percent =
@@ -154,9 +155,9 @@ XdsHttpFaultFilter::GenerateFilterConfig(
             fault_abort);
     if (percent != nullptr) {
       fault_injection_policy_json["abortPercentageNumerator"] =
-          envoy_type_v3_FractionalPercent_numerator(percent);
+          Json::FromNumber(envoy_type_v3_FractionalPercent_numerator(percent));
       fault_injection_policy_json["abortPercentageDenominator"] =
-          GetDenominator(percent);
+          Json::FromNumber(GetDenominator(percent));
     }
   }
   // Section 2: Parse the delay injection config
@@ -171,15 +172,16 @@ XdsHttpFaultFilter::GenerateFilterConfig(
     if (delay_duration != nullptr) {
       ValidationErrors::ScopedField field(errors, ".fixed_delay");
       Duration duration = ParseDuration(delay_duration, errors);
-      fault_injection_policy_json["delay"] = duration.ToJsonString();
+      fault_injection_policy_json["delay"] =
+          Json::FromString(duration.ToJsonString());
     }
     // Set the headers if we enabled header delay injection control
     if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
             fault_delay)) {
       fault_injection_policy_json["delayHeader"] =
-          "x-envoy-fault-delay-request";
+          Json::FromString("x-envoy-fault-delay-request");
       fault_injection_policy_json["delayPercentageHeader"] =
-          "x-envoy-fault-delay-request-percentage";
+          Json::FromString("x-envoy-fault-delay-request-percentage");
     }
     // Set the fraction percent
     auto* percent =
@@ -187,9 +189,9 @@ XdsHttpFaultFilter::GenerateFilterConfig(
             fault_delay);
     if (percent != nullptr) {
       fault_injection_policy_json["delayPercentageNumerator"] =
-          envoy_type_v3_FractionalPercent_numerator(percent);
+          Json::FromNumber(envoy_type_v3_FractionalPercent_numerator(percent));
       fault_injection_policy_json["delayPercentageDenominator"] =
-          GetDenominator(percent);
+          Json::FromNumber(GetDenominator(percent));
     }
   }
   // Section 3: Parse the maximum active faults
@@ -198,10 +200,10 @@ XdsHttpFaultFilter::GenerateFilterConfig(
           http_fault);
   if (max_fault_wrapper != nullptr) {
     fault_injection_policy_json["maxFaults"] =
-        google_protobuf_UInt32Value_value(max_fault_wrapper);
+        Json::FromNumber(google_protobuf_UInt32Value_value(max_fault_wrapper));
   }
   return FilterConfig{ConfigProtoName(),
-                      std::move(fault_injection_policy_json)};
+                      Json::FromObject(std::move(fault_injection_policy_json))};
 }
 
 absl::optional<XdsHttpFilterImpl::FilterConfig>
@@ -225,7 +227,8 @@ ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpFaultFilter::GenerateServiceConfig(
     const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override) const {
+    const FilterConfig* filter_config_override,
+    absl::string_view /*filter_name*/) const {
   Json policy_json = filter_config_override != nullptr
                          ? filter_config_override->config
                          : hcm_filter_config.config;

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

@@ -48,7 +48,8 @@ class XdsHttpFaultFilter : 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_http_filters.h

@@ -112,7 +112,8 @@ class XdsHttpFilterImpl {
   // there is no override in any of those locations.
   virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override) const = 0;
+      const FilterConfig* filter_config_override,
+      absl::string_view filter_name) const = 0;
 
   // Returns true if the filter is supported on clients; false otherwise
   virtual bool IsSupportedOnClients() const = 0;
@@ -138,7 +139,8 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
   const grpc_channel_filter* channel_filter() const override { return nullptr; }
   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 {
     // This will never be called, since channel_filter() returns null.
     return absl::UnimplementedError("router filter should never be called");
   }