build: don't reference enum constants via mangled names. (envoyproxy#…

…9450) Mangled names exist only to help with forward declarations, proto style explicitly discourages this, see https://developers.google.com/protocol-buffers/docs/reference/cpp-generated#enum. By avoiding the mangled names, we simplify API boosting tooling. Risk level: Low Testing: New check_format test. Part of envoyproxy#8082 Signed-off-by: Harvey Tuch <[email protected]> Signed-off-by: Prakhar <[email protected]>
prakhag1 · Jan 3, 2020 · 219da18 · 219da18
1 parent 9cb3ea4
commit 219da18
Show file tree

Hide file tree

Showing 33 changed files with 129 additions and 138 deletions.
diff --git a/STYLE.md b/STYLE.md
@@ -88,6 +88,8 @@
   [Google C++ style guide](https://google.github.io/styleguide/cppguide.html#Unnamed_Namespaces_and_Static_Variables)
    allows either, but in Envoy we prefer anonymous namespaces.
 * Braces are required for all control statements include single line if, while, etc. statements.
+* Don't use [mangled Protobuf enum
+  names](https://developers.google.com/protocol-buffers/docs/reference/cpp-generated#enum).
 
 # Error handling
 

diff --git a/source/common/upstream/original_dst_cluster.cc b/source/common/upstream/original_dst_cluster.cc
@@ -185,7 +185,7 @@ OriginalDstClusterFactory::createClusterImpl(
     throw EnvoyException(fmt::format(
         "cluster: LB policy {} is not valid for Cluster type {}. Only 'CLUSTER_PROVIDED' or "
         "'ORIGINAL_DST_LB' is allowed with cluster type 'ORIGINAL_DST'",
-        envoy::api::v2::Cluster_LbPolicy_Name(cluster.lb_policy()),
+        envoy::api::v2::Cluster::LbPolicy_Name(cluster.lb_policy()),
         envoy::api::v2::Cluster_DiscoveryType_Name(cluster.type())));
   }
 

diff --git a/source/common/upstream/upstream_impl.cc b/source/common/upstream/upstream_impl.cc
@@ -684,13 +684,13 @@ ClusterInfoImpl::ClusterInfoImpl(
       throw EnvoyException(
           fmt::format("cluster: LB policy {} is not valid for Cluster type {}. 'ORIGINAL_DST_LB' "
                       "is allowed only with cluster type 'ORIGINAL_DST'",
-                      envoy::api::v2::Cluster_LbPolicy_Name(config.lb_policy()),
+                      envoy::api::v2::Cluster::LbPolicy_Name(config.lb_policy()),
                       envoy::api::v2::Cluster_DiscoveryType_Name(config.type())));
     }
     if (config.has_lb_subset_config()) {
       throw EnvoyException(
           fmt::format("cluster: LB policy {} cannot be combined with lb_subset_config",
-                      envoy::api::v2::Cluster_LbPolicy_Name(config.lb_policy())));
+                      envoy::api::v2::Cluster::LbPolicy_Name(config.lb_policy())));
     }
 
     lb_type_ = LoadBalancerType::ClusterProvided;
@@ -702,7 +702,7 @@ ClusterInfoImpl::ClusterInfoImpl(
     if (config.has_lb_subset_config()) {
       throw EnvoyException(
           fmt::format("cluster: LB policy {} cannot be combined with lb_subset_config",
-                      envoy::api::v2::Cluster_LbPolicy_Name(config.lb_policy())));
+                      envoy::api::v2::Cluster::LbPolicy_Name(config.lb_policy())));
     }
 
     lb_type_ = LoadBalancerType::ClusterProvided;

diff --git a/source/exe/main_common.cc b/source/exe/main_common.cc
@@ -29,8 +29,7 @@ Server::DrainManagerPtr ProdComponentFactory::createDrainManager(Server::Instanc
   // The global drain manager only triggers on listener modification, which effectively is
   // hot restart at the global level. The per-listener drain managers decide whether to
   // to include /healthcheck/fail status.
-  return std::make_unique<Server::DrainManagerImpl>(server,
-                                                    envoy::api::v2::Listener_DrainType_MODIFY_ONLY);
+  return std::make_unique<Server::DrainManagerImpl>(server, envoy::api::v2::Listener::MODIFY_ONLY);
 }
 
 Runtime::LoaderPtr ProdComponentFactory::createRuntime(Server::Instance& server,

diff --git a/source/extensions/access_loggers/grpc/grpc_access_log_utils.cc b/source/extensions/access_loggers/grpc/grpc_access_log_utils.cc
@@ -19,16 +19,16 @@ using namespace envoy::data::accesslog::v2;
 // TLS version to the corresponding enum value used in gRPC access logs.
 TLSProperties_TLSVersion tlsVersionStringToEnum(const std::string& tls_version) {
   if (tls_version == "TLSv1") {
-    return TLSProperties_TLSVersion_TLSv1;
+    return TLSProperties::TLSv1;
   } else if (tls_version == "TLSv1.1") {
-    return TLSProperties_TLSVersion_TLSv1_1;
+    return TLSProperties::TLSv1_1;
   } else if (tls_version == "TLSv1.2") {
-    return TLSProperties_TLSVersion_TLSv1_2;
+    return TLSProperties::TLSv1_2;
   } else if (tls_version == "TLSv1.3") {
-    return TLSProperties_TLSVersion_TLSv1_3;
+    return TLSProperties::TLSv1_3;
   }
 
-  return TLSProperties_TLSVersion_VERSION_UNSPECIFIED;
+  return TLSProperties::VERSION_UNSPECIFIED;
 }
 
 } // namespace
@@ -90,8 +90,7 @@ void Utility::responseFlagsToAccessLogResponseFlags(
 
   if (stream_info.hasResponseFlag(StreamInfo::ResponseFlag::UnauthorizedExternalService)) {
     common_access_log.mutable_response_flags()->mutable_unauthorized_details()->set_reason(
-        envoy::data::accesslog::v2::ResponseFlags_Unauthorized_Reason::
-            ResponseFlags_Unauthorized_Reason_EXTERNAL_SERVICE);
+        envoy::data::accesslog::v2::ResponseFlags::Unauthorized::EXTERNAL_SERVICE);
   }
 
   if (stream_info.hasResponseFlag(StreamInfo::ResponseFlag::RateLimitServiceError)) {

diff --git a/source/extensions/filters/common/ratelimit/ratelimit_impl.cc b/source/extensions/filters/common/ratelimit/ratelimit_impl.cc
@@ -66,9 +66,8 @@ void GrpcClientImpl::onSuccess(
     std::unique_ptr<envoy::service::ratelimit::v2::RateLimitResponse>&& response,
     Tracing::Span& span) {
   LimitStatus status = LimitStatus::OK;
-  ASSERT(response->overall_code() != envoy::service::ratelimit::v2::RateLimitResponse_Code_UNKNOWN);
-  if (response->overall_code() ==
-      envoy::service::ratelimit::v2::RateLimitResponse_Code_OVER_LIMIT) {
+  ASSERT(response->overall_code() != envoy::service::ratelimit::v2::RateLimitResponse::UNKNOWN);
+  if (response->overall_code() == envoy::service::ratelimit::v2::RateLimitResponse::OVER_LIMIT) {
     status = LimitStatus::OverLimit;
     span.setTag(Constants::get().TraceStatus, Constants::get().TraceOverLimit);
   } else {

diff --git a/source/extensions/filters/common/rbac/engine_impl.cc b/source/extensions/filters/common/rbac/engine_impl.cc
@@ -12,8 +12,7 @@ namespace RBAC {
 
 RoleBasedAccessControlEngineImpl::RoleBasedAccessControlEngineImpl(
     const envoy::config::rbac::v2::RBAC& rules)
-    : allowed_if_matched_(rules.action() ==
-                          envoy::config::rbac::v2::RBAC_Action::RBAC_Action_ALLOW) {
+    : allowed_if_matched_(rules.action() == envoy::config::rbac::v2::RBAC::ALLOW) {
   // guard expression builder by presence of a condition in policies
   for (const auto& policy : rules.policies()) {
     if (policy.second.has_condition()) {

diff --git a/source/extensions/filters/http/gzip/gzip_filter.cc b/source/extensions/filters/http/gzip/gzip_filter.cc
@@ -56,11 +56,9 @@ GzipFilterConfig::GzipFilterConfig(const envoy::config::filter::http::gzip::v2::
 Compressor::ZlibCompressorImpl::CompressionLevel GzipFilterConfig::compressionLevelEnum(
     envoy::config::filter::http::gzip::v2::Gzip_CompressionLevel_Enum compression_level) {
   switch (compression_level) {
-  case envoy::config::filter::http::gzip::v2::Gzip_CompressionLevel_Enum::
-      Gzip_CompressionLevel_Enum_BEST:
+  case envoy::config::filter::http::gzip::v2::Gzip::CompressionLevel::BEST:
     return Compressor::ZlibCompressorImpl::CompressionLevel::Best;
-  case envoy::config::filter::http::gzip::v2::Gzip_CompressionLevel_Enum::
-      Gzip_CompressionLevel_Enum_SPEED:
+  case envoy::config::filter::http::gzip::v2::Gzip::CompressionLevel::SPEED:
     return Compressor::ZlibCompressorImpl::CompressionLevel::Speed;
   default:
     return Compressor::ZlibCompressorImpl::CompressionLevel::Standard;
@@ -70,14 +68,11 @@ Compressor::ZlibCompressorImpl::CompressionLevel GzipFilterConfig::compressionLe
 Compressor::ZlibCompressorImpl::CompressionStrategy GzipFilterConfig::compressionStrategyEnum(
     envoy::config::filter::http::gzip::v2::Gzip_CompressionStrategy compression_strategy) {
   switch (compression_strategy) {
-  case envoy::config::filter::http::gzip::v2::Gzip_CompressionStrategy::
-      Gzip_CompressionStrategy_RLE:
+  case envoy::config::filter::http::gzip::v2::Gzip::RLE:
     return Compressor::ZlibCompressorImpl::CompressionStrategy::Rle;
-  case envoy::config::filter::http::gzip::v2::Gzip_CompressionStrategy::
-      Gzip_CompressionStrategy_FILTERED:
+  case envoy::config::filter::http::gzip::v2::Gzip::FILTERED:
     return Compressor::ZlibCompressorImpl::CompressionStrategy::Filtered;
-  case envoy::config::filter::http::gzip::v2::Gzip_CompressionStrategy::
-      Gzip_CompressionStrategy_HUFFMAN:
+  case envoy::config::filter::http::gzip::v2::Gzip::HUFFMAN:
     return Compressor::ZlibCompressorImpl::CompressionStrategy::Huffman;
   default:
     return Compressor::ZlibCompressorImpl::CompressionStrategy::Standard;

diff --git a/source/extensions/filters/http/header_to_metadata/header_to_metadata_filter.cc b/source/extensions/filters/http/header_to_metadata/header_to_metadata_filter.cc
@@ -97,7 +97,7 @@ bool HeaderToMetadataFilter::addMetadata(StructMap& map, const std::string& meta
   }
 
   std::string decodedValue = std::string(value);
-  if (encode == envoy::config::filter::http::header_to_metadata::v2::Config_ValueEncode_BASE64) {
+  if (encode == envoy::config::filter::http::header_to_metadata::v2::Config::BASE64) {
     decodedValue = Base64::decodeWithoutPadding(value);
     if (decodedValue.empty()) {
       ENVOY_LOG(debug, "Base64 decode failed");
@@ -107,10 +107,10 @@ bool HeaderToMetadataFilter::addMetadata(StructMap& map, const std::string& meta
 
   // Sane enough, add the key/value.
   switch (type) {
-  case envoy::config::filter::http::header_to_metadata::v2::Config_ValueType_STRING:
+  case envoy::config::filter::http::header_to_metadata::v2::Config::STRING:
     val.set_string_value(std::move(decodedValue));
     break;
-  case envoy::config::filter::http::header_to_metadata::v2::Config_ValueType_NUMBER: {
+  case envoy::config::filter::http::header_to_metadata::v2::Config::NUMBER: {
     double dval;
     if (absl::SimpleAtod(StringUtil::trim(decodedValue), &dval)) {
       val.set_number_value(dval);
@@ -120,7 +120,7 @@ bool HeaderToMetadataFilter::addMetadata(StructMap& map, const std::string& meta
     }
     break;
   }
-  case envoy::config::filter::http::header_to_metadata::v2::Config_ValueType_PROTOBUF_VALUE: {
+  case envoy::config::filter::http::header_to_metadata::v2::Config::PROTOBUF_VALUE: {
     if (!val.ParseFromString(decodedValue)) {
       ENVOY_LOG(debug, "parse from decoded string failed");
       return false;

diff --git a/source/extensions/filters/http/ip_tagging/ip_tagging_filter.h b/source/extensions/filters/http/ip_tagging/ip_tagging_filter.h
@@ -48,11 +48,11 @@ class IpTaggingFilterConfig {
   static FilterRequestType requestTypeEnum(
       envoy::config::filter::http::ip_tagging::v3alpha::IPTagging::RequestType request_type) {
     switch (request_type) {
-    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging_RequestType_BOTH:
+    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging::BOTH:
       return FilterRequestType::BOTH;
-    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging_RequestType_INTERNAL:
+    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging::INTERNAL:
       return FilterRequestType::INTERNAL;
-    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging_RequestType_EXTERNAL:
+    case envoy::config::filter::http::ip_tagging::v3alpha::IPTagging::EXTERNAL:
       return FilterRequestType::EXTERNAL;
     default:
       NOT_REACHED_GCOVR_EXCL_LINE;

diff --git a/source/extensions/filters/network/common/redis/client_impl.cc b/source/extensions/filters/network/common/redis/client_impl.cc
@@ -29,23 +29,20 @@ ConfigImpl::ConfigImpl(
           PROTOBUF_GET_WRAPPED_OR_DEFAULT(config, max_upstream_unknown_connections, 100)),
       enable_command_stats_(config.enable_command_stats()) {
   switch (config.read_policy()) {
-  case envoy::config::filter::network::redis_proxy::v2::
-      RedisProxy_ConnPoolSettings_ReadPolicy_MASTER:
+  case envoy::config::filter::network::redis_proxy::v2::RedisProxy::ConnPoolSettings::MASTER:
     read_policy_ = ReadPolicy::Master;
     break;
-  case envoy::config::filter::network::redis_proxy::v2::
-      RedisProxy_ConnPoolSettings_ReadPolicy_PREFER_MASTER:
+  case envoy::config::filter::network::redis_proxy::v2::RedisProxy::ConnPoolSettings::PREFER_MASTER:
     read_policy_ = ReadPolicy::PreferMaster;
     break;
-  case envoy::config::filter::network::redis_proxy::v2::
-      RedisProxy_ConnPoolSettings_ReadPolicy_REPLICA:
+  case envoy::config::filter::network::redis_proxy::v2::RedisProxy::ConnPoolSettings::REPLICA:
     read_policy_ = ReadPolicy::Replica;
     break;
-  case envoy::config::filter::network::redis_proxy::v2::
-      RedisProxy_ConnPoolSettings_ReadPolicy_PREFER_REPLICA:
+  case envoy::config::filter::network::redis_proxy::v2::RedisProxy::ConnPoolSettings::
+      PREFER_REPLICA:
     read_policy_ = ReadPolicy::PreferReplica;
     break;
-  case envoy::config::filter::network::redis_proxy::v2::RedisProxy_ConnPoolSettings_ReadPolicy_ANY:
+  case envoy::config::filter::network::redis_proxy::v2::RedisProxy::ConnPoolSettings::ANY:
     read_policy_ = ReadPolicy::Any;
     break;
   default:

diff --git a/source/extensions/tracers/xray/config.cc b/source/extensions/tracers/xray/config.cc
@@ -35,8 +35,7 @@ XRayTracerFactory::createHttpTracerTyped(const trace::XRayConfig& proto_config,
     ENVOY_LOG(error, "Failed to read sampling rules manifest because of {}.", e.what());
   }
 
-  if (proto_config.daemon_endpoint().protocol() !=
-      api::core::SocketAddress::Protocol::SocketAddress_Protocol_UDP) {
+  if (proto_config.daemon_endpoint().protocol() != api::core::SocketAddress::UDP) {
     throw EnvoyException("X-Ray daemon endpoint must be a UDP socket address");
   }
 

diff --git a/source/server/drain_manager_impl.cc b/source/server/drain_manager_impl.cc
@@ -25,7 +25,7 @@ bool DrainManagerImpl::drainClose() const {
   // if even in the case of server health check failure we had some period of drain ramp up. This
   // would allow the other side to fail health check for the host which will require some thread
   // jumps versus immediately start GOAWAY/connection thrashing.
-  if (drain_type_ == envoy::api::v2::Listener_DrainType_DEFAULT && server_.healthCheckFailed()) {
+  if (drain_type_ == envoy::api::v2::Listener::DEFAULT && server_.healthCheckFailed()) {
     return true;
   }
 

diff --git a/source/server/filter_chain_manager_impl.cc b/source/server/filter_chain_manager_impl.cc
@@ -359,13 +359,10 @@ const Network::FilterChain* FilterChainManagerImpl::findFilterChainForApplicatio
 const Network::FilterChain* FilterChainManagerImpl::findFilterChainForSourceTypes(
     const SourceTypesArray& source_types, const Network::ConnectionSocket& socket) const {
 
-  const auto& filter_chain_local =
-      source_types[envoy::api::v2::listener::FilterChainMatch_ConnectionSourceType::
-                       FilterChainMatch_ConnectionSourceType_LOCAL];
+  const auto& filter_chain_local = source_types[envoy::api::v2::listener::FilterChainMatch::LOCAL];
 
   const auto& filter_chain_external =
-      source_types[envoy::api::v2::listener::FilterChainMatch_ConnectionSourceType::
-                       FilterChainMatch_ConnectionSourceType_EXTERNAL];
+      source_types[envoy::api::v2::listener::FilterChainMatch::EXTERNAL];
 
   // isLocalConnection can be expensive. Call it only if LOCAL or EXTERNAL have entries.
   const bool is_local_connection =
@@ -383,9 +380,7 @@ const Network::FilterChain* FilterChainManagerImpl::findFilterChainForSourceType
     }
   }
 
-  const auto& filter_chain_any =
-      source_types[envoy::api::v2::listener::FilterChainMatch_ConnectionSourceType::
-                       FilterChainMatch_ConnectionSourceType_ANY];
+  const auto& filter_chain_any = source_types[envoy::api::v2::listener::FilterChainMatch::ANY];
 
   if (!filter_chain_any.first.empty()) {
     return findFilterChainForSourceIpAndPort(*filter_chain_any.second, socket);

diff --git a/source/server/http/admin.cc b/source/server/http/admin.cc
@@ -782,8 +782,8 @@ Http::Code AdminImpl::handlerReady(absl::string_view, Http::HeaderMap&, Buffer::
   const envoy::admin::v2alpha::ServerInfo::State state =
       Utility::serverState(server_.initManager().state(), server_.healthCheckFailed());
 
-  response.add(envoy::admin::v2alpha::ServerInfo_State_Name(state) + "\n");
-  Http::Code code = state == envoy::admin::v2alpha::ServerInfo_State_LIVE
+  response.add(envoy::admin::v2alpha::ServerInfo::State_Name(state) + "\n");
+  Http::Code code = state == envoy::admin::v2alpha::ServerInfo::LIVE
                         ? Http::Code::OK
                         : Http::Code::ServiceUnavailable;
   return code;

diff --git a/test/common/upstream/cluster_manager_impl_test.cc b/test/common/upstream/cluster_manager_impl_test.cc
@@ -393,15 +393,15 @@ class ClusterManagerSubsetInitializationTest
   ClusterManagerSubsetInitializationTest() = default;
 
   static std::vector<envoy::api::v2::Cluster_LbPolicy> lbPolicies() {
-    int first = static_cast<int>(envoy::api::v2::Cluster_LbPolicy_LbPolicy_MIN);
-    int last = static_cast<int>(envoy::api::v2::Cluster_LbPolicy_LbPolicy_MAX);
+    int first = static_cast<int>(envoy::api::v2::Cluster::LbPolicy_MIN);
+    int last = static_cast<int>(envoy::api::v2::Cluster::LbPolicy_MAX);
     ASSERT(first < last);
 
     std::vector<envoy::api::v2::Cluster_LbPolicy> policies;
     for (int i = first; i <= last; i++) {
-      if (envoy::api::v2::Cluster_LbPolicy_IsValid(i)) {
+      if (envoy::api::v2::Cluster::LbPolicy_IsValid(i)) {
         auto policy = static_cast<envoy::api::v2::Cluster_LbPolicy>(i);
-        if (policy != envoy::api::v2::Cluster_LbPolicy_LOAD_BALANCING_POLICY_CONFIG) {
+        if (policy != envoy::api::v2::Cluster::LOAD_BALANCING_POLICY_CONFIG) {
           policies.push_back(policy);
         }
       }
@@ -410,7 +410,7 @@ class ClusterManagerSubsetInitializationTest
   }
 
   static std::string paramName(const testing::TestParamInfo<ParamType>& info) {
-    const std::string& name = envoy::api::v2::Cluster_LbPolicy_Name(info.param);
+    const std::string& name = envoy::api::v2::Cluster::LbPolicy_Name(info.param);
     return absl::StrReplaceAll(name, {{"_", ""}});
   }
 };
@@ -443,23 +443,23 @@ TEST_P(ClusterManagerSubsetInitializationTest, SubsetLoadBalancerInitialization)
                   port_value: 8001
   )EOF";
 
-  const std::string& policy_name = envoy::api::v2::Cluster_LbPolicy_Name(GetParam());
+  const std::string& policy_name = envoy::api::v2::Cluster::LbPolicy_Name(GetParam());
 
   std::string cluster_type = "type: STATIC";
-  if (GetParam() == envoy::api::v2::Cluster_LbPolicy_ORIGINAL_DST_LB) {
+  if (GetParam() == envoy::api::v2::Cluster::ORIGINAL_DST_LB) {
     cluster_type = "type: ORIGINAL_DST";
-  } else if (GetParam() == envoy::api::v2::Cluster_LbPolicy_CLUSTER_PROVIDED) {
+  } else if (GetParam() == envoy::api::v2::Cluster::CLUSTER_PROVIDED) {
     // This custom cluster type is registered by linking test/integration/custom/static_cluster.cc.
     cluster_type = "cluster_type: { name: envoy.clusters.custom_static_with_lb }";
   }
   const std::string yaml = fmt::format(yamlPattern, cluster_type, policy_name);
 
-  if (GetParam() == envoy::api::v2::Cluster_LbPolicy_ORIGINAL_DST_LB ||
-      GetParam() == envoy::api::v2::Cluster_LbPolicy_CLUSTER_PROVIDED) {
+  if (GetParam() == envoy::api::v2::Cluster::ORIGINAL_DST_LB ||
+      GetParam() == envoy::api::v2::Cluster::CLUSTER_PROVIDED) {
     EXPECT_THROW_WITH_MESSAGE(
         create(parseBootstrapFromV2Yaml(yaml)), EnvoyException,
         fmt::format("cluster: LB policy {} cannot be combined with lb_subset_config",
-                    envoy::api::v2::Cluster_LbPolicy_Name(GetParam())));
+                    envoy::api::v2::Cluster::LbPolicy_Name(GetParam())));
 
   } else {
     create(parseBootstrapFromV2Yaml(yaml));

diff --git a/test/common/upstream/ring_hash_lb_test.cc b/test/common/upstream/ring_hash_lb_test.cc
@@ -208,8 +208,7 @@ TEST_P(RingHashLoadBalancerTest, BasicWithMurmur2) {
   hostSet().runCallbacks({}, {});
 
   config_ = envoy::api::v2::Cluster::RingHashLbConfig();
-  config_.value().set_hash_function(envoy::api::v2::Cluster_RingHashLbConfig_HashFunction::
-                                        Cluster_RingHashLbConfig_HashFunction_MURMUR_HASH_2);
+  config_.value().set_hash_function(envoy::api::v2::Cluster::RingHashLbConfig::MURMUR_HASH_2);
   config_.value().mutable_minimum_ring_size()->set_value(12);
   init();
   EXPECT_EQ(12, lb_->stats().size_.value());

diff --git a/test/extensions/access_loggers/grpc/grpc_access_log_utils_test.cc b/test/extensions/access_loggers/grpc/grpc_access_log_utils_test.cc
@@ -33,8 +33,7 @@ TEST(UtilityResponseFlagsToAccessLogResponseFlagsTest, All) {
   common_access_log_expected.mutable_response_flags()->set_fault_injected(true);
   common_access_log_expected.mutable_response_flags()->set_rate_limited(true);
   common_access_log_expected.mutable_response_flags()->mutable_unauthorized_details()->set_reason(
-      envoy::data::accesslog::v2::ResponseFlags_Unauthorized_Reason::
-          ResponseFlags_Unauthorized_Reason_EXTERNAL_SERVICE);
+      envoy::data::accesslog::v2::ResponseFlags::Unauthorized::EXTERNAL_SERVICE);
   common_access_log_expected.mutable_response_flags()->set_rate_limit_service_error(true);
   common_access_log_expected.mutable_response_flags()->set_downstream_connection_termination(true);
   common_access_log_expected.mutable_response_flags()->set_upstream_retry_limit_exceeded(true);