grpc 1.66.0 → 1.67.0.pre1

data/src/core/client_channel/subchannel.cc

@@ -417,12 +417,11 @@ class Subchannel::ConnectedSubchannelStateWatcher final
       if (c->connected_subchannel_ == nullptr) return;
       if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
           new_state == GRPC_CHANNEL_SHUTDOWN) {
-        if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-          LOG(INFO) << "subchannel " << c << " " << c->key_.ToString()
-                    << ": Connected subchannel "
-                    << c->connected_subchannel_.get() << " reports "
-                    << ConnectivityStateName(new_state) << ": " << status;
-        }
+        GRPC_TRACE_LOG(subchannel, INFO)
+            << "subchannel " << c << " " << c->key_.ToString()
+            << ": Connected subchannel " << c->connected_subchannel_.get()
+            << " reports " << ConnectivityStateName(new_state) << ": "
+            << status;
         c->connected_subchannel_.reset();
         if (c->channelz_node() != nullptr) {
           c->channelz_node()->SetChildSocket(nullptr);
@@ -602,10 +601,9 @@ void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
   // Only update the value if the new keepalive time is larger.
   if (new_keepalive_time > keepalive_time_) {
     keepalive_time_ = new_keepalive_time;
-    if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-      LOG(INFO) << "subchannel " << this << " " << key_.ToString()
-                << ": throttling keepalive time to " << new_keepalive_time;
-    }
+    GRPC_TRACE_LOG(subchannel, INFO)
+        << "subchannel " << this << " " << key_.ToString()
+        << ": throttling keepalive time to " << new_keepalive_time;
     args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time);
   }
 }
@@ -758,17 +756,17 @@ void Subchannel::OnRetryTimer() {
 
 void Subchannel::OnRetryTimerLocked() {
   if (shutdown_) return;
-  if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-    LOG(INFO) << "subchannel " << this << " " << key_.ToString()
-              << ": backoff delay elapsed, reporting IDLE";
-  }
+  GRPC_TRACE_LOG(subchannel, INFO)
+      << "subchannel " << this << " " << key_.ToString()
+      << ": backoff delay elapsed, reporting IDLE";
   SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, absl::OkStatus());
 }
 
 void Subchannel::StartConnectingLocked() {
   // Set next attempt time.
-  const Timestamp min_deadline = min_connect_timeout_ + Timestamp::Now();
-  next_attempt_time_ = backoff_.NextAttemptTime();
+  const Timestamp now = Timestamp::Now();
+  const Timestamp min_deadline = now + min_connect_timeout_;
+  next_attempt_time_ = now + backoff_.NextAttemptDelay();
   // Report CONNECTING.
   SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::OkStatus());
   // Start connection attempt.
@@ -805,12 +803,10 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
     const Duration time_until_next_attempt =
         next_attempt_time_ - Timestamp::Now();
-    if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-      LOG(INFO) << "subchannel " << this << " " << key_.ToString()
-                << ": connect failed (" << StatusToString(error)
-                << "), backing off for " << time_until_next_attempt.millis()
-                << " ms";
-    }
+    GRPC_TRACE_LOG(subchannel, INFO)
+        << "subchannel " << this << " " << key_.ToString()
+        << ": connect failed (" << StatusToString(error)
+        << "), backing off for " << time_until_next_attempt.millis() << " ms";
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
     retry_timer_handle_ = event_engine_->RunAfter(
@@ -895,11 +891,9 @@ bool Subchannel::PublishTransportLocked() {
   }
   connecting_result_.Reset();
   // Publish.
-  if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-    LOG(INFO) << "subchannel " << this << " " << key_.ToString()
-              << ": new connected subchannel at "
-              << connected_subchannel_.get();
-  }
+  GRPC_TRACE_LOG(subchannel, INFO)
+      << "subchannel " << this << " " << key_.ToString()
+      << ": new connected subchannel at " << connected_subchannel_.get();
   if (channelz_node_ != nullptr) {
     channelz_node_->SetChildSocket(std::move(socket_node));
   }

data/src/core/client_channel/subchannel_stream_client.cc

@@ -130,7 +130,7 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   if (event_handler_ != nullptr) {
     event_handler_->OnRetryTimerStartLocked(this);
   }
-  const Duration timeout = retry_backoff_.NextAttemptTime() - Timestamp::Now();
+  const Duration timeout = retry_backoff_.NextAttemptDelay();
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
     LOG(INFO) << tracer_ << " " << this
               << ": SubchannelStreamClient health check call lost...";

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -128,21 +128,20 @@ void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
   if (md.get(GrpcCallWasCancelled()).value_or(false)) return;
   auto* ctx = MaybeGetContext<BackendMetricProvider>();
   if (ctx == nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-      LOG(INFO) << "[" << this << "] No BackendMetricProvider.";
-    }
+    GRPC_TRACE_LOG(backend_metric_filter, INFO)
+        << "[" << this << "] No BackendMetricProvider.";
     return;
   }
   absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
   if (serialized.has_value() && !serialized->empty()) {
-    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-      LOG(INFO) << "[" << this
-                << "] Backend metrics serialized. size: " << serialized->size();
-    }
+    GRPC_TRACE_LOG(backend_metric_filter, INFO)
+        << "[" << this
+        << "] Backend metrics serialized. size: " << serialized->size();
     md.Set(EndpointLoadMetricsBinMetadata(),
            Slice::FromCopiedString(std::move(*serialized)));
-  } else if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-    LOG(INFO) << "[" << this << "] No backend metrics.";
+  } else {
+    GRPC_TRACE_LOG(backend_metric_filter, INFO)
+        << "[" << this << "] No backend metrics.";
   }
 }
 

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -29,7 +29,6 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/promise_based_filter.h"

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -150,10 +150,9 @@ FaultInjectionFilter::FaultInjectionFilter(ChannelFilter::Args filter_args)
 ArenaPromise<absl::Status> FaultInjectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, FaultInjectionFilter* filter) {
   auto decision = filter->MakeInjectionDecision(md);
-  if (GRPC_TRACE_FLAG_ENABLED(fault_injection_filter)) {
-    LOG(INFO) << "chand=" << this << ": Fault injection triggered "
-              << decision.ToString();
-  }
+  GRPC_TRACE_LOG(fault_injection_filter, INFO)
+      << "chand=" << this << ": Fault injection triggered "
+      << decision.ToString();
   auto delay = decision.DelayUntil();
   return TrySeq(Sleep(delay), [decision = std::move(decision)]() {
     return decision.MaybeAbort();

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.cc

@@ -0,0 +1,167 @@
+//
+// 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.
+//
+
+#include "src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/strings/str_cat.h"
+
+#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/security/context/security_context.h"
+#include "src/core/lib/security/credentials/gcp_service_account_identity/gcp_service_account_identity_credentials.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/resolver/xds/xds_resolver_attributes.h"
+#include "src/core/service_config/service_config.h"
+#include "src/core/service_config/service_config_call_data.h"
+
+namespace grpc_core {
+
+const NoInterceptor GcpAuthenticationFilter::Call::OnClientToServerMessage;
+const NoInterceptor GcpAuthenticationFilter::Call::OnClientToServerHalfClose;
+const NoInterceptor GcpAuthenticationFilter::Call::OnServerInitialMetadata;
+const NoInterceptor GcpAuthenticationFilter::Call::OnServerToClientMessage;
+const NoInterceptor GcpAuthenticationFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor GcpAuthenticationFilter::Call::OnFinalize;
+
+absl::Status GcpAuthenticationFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& /*md*/, GcpAuthenticationFilter* filter) {
+  // Get the cluster name chosen for this RPC.
+  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
+  auto cluster_attribute =
+      service_config_call_data->GetCallAttribute<XdsClusterAttribute>();
+  if (cluster_attribute == nullptr) {
+    // Can't happen, but be defensive.
+    return absl::InternalError(
+        "GCP authentication filter: call has no xDS cluster attribute");
+  }
+  absl::string_view cluster_name = cluster_attribute->cluster();
+  if (!absl::ConsumePrefix(&cluster_name, "cluster:")) {
+    return absl::OkStatus();  // Cluster specifier plugin.
+  }
+  // Look up the CDS resource for the cluster.
+  auto it = filter->xds_config_->clusters.find(cluster_name);
+  if (it == filter->xds_config_->clusters.end()) {
+    // Can't happen, but be defensive.
+    return absl::InternalError(
+        absl::StrCat("GCP authentication filter: xDS cluster ", cluster_name,
+                     " not found in XdsConfig"));
+  }
+  if (!it->second.ok()) {
+    // Cluster resource had an error, so fail the call.
+    // Note: For wait_for_ready calls, this does the wrong thing by
+    // failing the call instead of queuing it, but there's no easy
+    // way to queue the call here until we get a valid CDS resource,
+    // because once that happens, a new instance of this filter will be
+    // swapped in for subsequent calls, but *this* call is already tied
+    // to this filter instance, which will never see the update.
+    return absl::UnavailableError(
+        absl::StrCat("GCP authentication filter: CDS resource unavailable for ",
+                     cluster_name));
+  }
+  if (it->second->cluster == nullptr) {
+    // Can't happen, but be defensive.
+    return absl::InternalError(absl::StrCat(
+        "GCP authentication filter: CDS resource not present for cluster ",
+        cluster_name));
+  }
+  auto& metadata_map = it->second->cluster->metadata;
+  const XdsMetadataValue* metadata_value =
+      metadata_map.Find(filter->filter_config_->filter_instance_name);
+  // If no audience in the cluster, then no need to add call creds.
+  if (metadata_value == nullptr) return absl::OkStatus();
+  // If the entry is present but the wrong type, fail the RPC.
+  if (metadata_value->type() != XdsGcpAuthnAudienceMetadataValue::Type()) {
+    return absl::UnavailableError(absl::StrCat(
+        "GCP authentication filter: audience metadata in wrong format for "
+        "cluster ",
+        cluster_name));
+  }
+  // Get the call creds instance.
+  auto creds = filter->GetCallCredentials(
+      DownCast<const XdsGcpAuthnAudienceMetadataValue*>(metadata_value)->url());
+  // Add the call creds instance to the call.
+  auto* arena = GetContext<Arena>();
+  auto* security_ctx = DownCast<grpc_client_security_context*>(
+      arena->GetContext<SecurityContext>());
+  if (security_ctx == nullptr) {
+    security_ctx = arena->New<grpc_client_security_context>(std::move(creds));
+    arena->SetContext<SecurityContext>(security_ctx);
+  } else {
+    security_ctx->creds = std::move(creds);
+  }
+  return absl::OkStatus();
+}
+
+const grpc_channel_filter GcpAuthenticationFilter::kFilter =
+    MakePromiseBasedFilter<GcpAuthenticationFilter, FilterEndpoint::kClient,
+                           0>();
+
+absl::StatusOr<std::unique_ptr<GcpAuthenticationFilter>>
+GcpAuthenticationFilter::Create(const ChannelArgs& args,
+                                ChannelFilter::Args filter_args) {
+  auto* service_config = args.GetObject<ServiceConfig>();
+  if (service_config == nullptr) {
+    return absl::InvalidArgumentError(
+        "gcp_auth: no service config in channel args");
+  }
+  auto* config = static_cast<const GcpAuthenticationParsedConfig*>(
+      service_config->GetGlobalParsedConfig(
+          GcpAuthenticationServiceConfigParser::ParserIndex()));
+  if (config == nullptr) {
+    return absl::InvalidArgumentError("gcp_auth: parsed config not found");
+  }
+  auto* filter_config = config->GetConfig(filter_args.instance_id());
+  if (filter_config == nullptr) {
+    return absl::InvalidArgumentError(
+        "gcp_auth: filter instance ID not found in filter config");
+  }
+  auto xds_config = args.GetObjectRef<XdsConfig>();
+  if (xds_config == nullptr) {
+    return absl::InvalidArgumentError(
+        "gcp_auth: xds config not found in channel args");
+  }
+  return std::make_unique<GcpAuthenticationFilter>(filter_config,
+                                                   std::move(xds_config));
+}
+
+GcpAuthenticationFilter::GcpAuthenticationFilter(
+    const GcpAuthenticationParsedConfig::Config* filter_config,
+    RefCountedPtr<const XdsConfig> xds_config)
+    : filter_config_(filter_config),
+      xds_config_(std::move(xds_config)),
+      cache_(filter_config->cache_size) {}
+
+RefCountedPtr<grpc_call_credentials>
+GcpAuthenticationFilter::GetCallCredentials(const std::string& audience) {
+  MutexLock lock(&mu_);
+  return cache_.GetOrInsert(audience, [](const std::string& audience) {
+    return MakeRefCounted<GcpServiceAccountIdentityCallCredentials>(audience);
+  });
+}
+
+void GcpAuthenticationFilterRegister(CoreConfiguration::Builder* builder) {
+  GcpAuthenticationServiceConfigParser::Register(builder);
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h

@@ -0,0 +1,82 @@
+//
+// 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_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_FILTER_H
+
+#include <memory>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/resolver/xds/xds_config.h"
+#include "src/core/util/lru_cache.h"
+
+namespace grpc_core {
+
+// xDS GCP Authentication filter.
+// https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/gcp_authn_filter
+class GcpAuthenticationFilter
+    : public ImplementChannelFilter<GcpAuthenticationFilter> {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::string_view TypeName() { return "gcp_authentication_filter"; }
+
+  static absl::StatusOr<std::unique_ptr<GcpAuthenticationFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  GcpAuthenticationFilter(
+      const GcpAuthenticationParsedConfig::Config* filter_config,
+      RefCountedPtr<const XdsConfig> xds_config);
+
+  class Call {
+   public:
+    absl::Status OnClientInitialMetadata(ClientMetadata& /*md*/,
+                                         GcpAuthenticationFilter* filter);
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnFinalize;
+  };
+
+ private:
+  RefCountedPtr<grpc_call_credentials> GetCallCredentials(
+      const std::string& audience);
+
+  const GcpAuthenticationParsedConfig::Config* filter_config_;
+  const RefCountedPtr<const XdsConfig> xds_config_;
+
+  Mutex mu_;
+  LruCache<std::string /*audience*/, RefCountedPtr<grpc_call_credentials>>
+      cache_ ABSL_GUARDED_BY(&mu_);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_FILTER_H

data/src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.cc

@@ -0,0 +1,81 @@
+//
+// 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
+
+#include <vector>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+
+const JsonLoaderInterface* GcpAuthenticationParsedConfig::Config::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<Config>()
+          .Field("filter_instance_name", &Config::filter_instance_name)
+          .OptionalField("cache_size", &Config::cache_size)
+          .Finish();
+  return loader;
+}
+
+void GcpAuthenticationParsedConfig::Config::JsonPostLoad(
+    const Json&, const JsonArgs&, ValidationErrors* errors) {
+  if (cache_size == 0) {
+    ValidationErrors::ScopedField field(errors, ".cache_size");
+    errors->AddError("must be non-zero");
+  }
+}
+
+const JsonLoaderInterface* GcpAuthenticationParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<GcpAuthenticationParsedConfig>()
+          .OptionalField("gcp_authentication",
+                         &GcpAuthenticationParsedConfig::configs_)
+          .Finish();
+  return loader;
+}
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+GcpAuthenticationServiceConfigParser::ParseGlobalParams(
+    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
+  // Only parse config if the following channel arg is enabled.
+  if (!args.GetBool(GRPC_ARG_PARSE_GCP_AUTHENTICATION_METHOD_CONFIG)
+           .value_or(false)) {
+    return nullptr;
+  }
+  // Parse config from json.
+  return LoadFromJson<std::unique_ptr<GcpAuthenticationParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+void GcpAuthenticationServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<GcpAuthenticationServiceConfigParser>());
+}
+
+size_t GcpAuthenticationServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h

@@ -0,0 +1,87 @@
+//
+// 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_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+
+// Channel arg key for enabling parsing fault injection via method config.
+#define GRPC_ARG_PARSE_GCP_AUTHENTICATION_METHOD_CONFIG \
+  "grpc.internal.parse_gcp_authentication_method_config"
+
+namespace grpc_core {
+
+class GcpAuthenticationParsedConfig : public ServiceConfigParser::ParsedConfig {
+ public:
+  struct Config {
+    std::string filter_instance_name;
+    uint64_t cache_size = 10;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors);
+  };
+
+  // Returns the config at the specified index.  There might be multiple
+  // GCP auth filters in the list of HTTP filters at the same time.
+  // The order of the list is stable, and an index is used to keep track of
+  // their relative positions.  Each filter instance uses this method to
+  // access the appropriate parsed config for that instance.
+  const Config* GetConfig(size_t index) const {
+    if (index >= configs_.size()) return nullptr;
+    return &configs_[index];
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
+ private:
+  std::vector<Config> configs_;
+};
+
+class GcpAuthenticationServiceConfigParser final
+    : public ServiceConfigParser::Parser {
+ public:
+  absl::string_view name() const override { return parser_name(); }
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
+      const ChannelArgs& args, const Json& json,
+      ValidationErrors* errors) override;
+  // Returns the parser index for the parser.
+  static size_t ParserIndex();
+  // Registers the parser.
+  static void Register(CoreConfiguration::Builder* builder);
+
+ private:
+  static absl::string_view parser_name() { return "gcp_auth"; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -111,10 +111,9 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
 
 MessageHandle ChannelCompression::CompressMessage(
     MessageHandle message, grpc_compression_algorithm algorithm) const {
-  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
-    LOG(INFO) << "CompressMessage: len=" << message->payload()->Length()
-              << " alg=" << algorithm << " flags=" << message->flags();
-  }
+  GRPC_TRACE_LOG(compression, INFO)
+      << "CompressMessage: len=" << message->payload()->Length()
+      << " alg=" << algorithm << " flags=" << message->flags();
   auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordSendMessage(*message->payload());
@@ -166,11 +165,10 @@ MessageHandle ChannelCompression::CompressMessage(
 
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     bool is_client, MessageHandle message, DecompressArgs args) const {
-  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
-    LOG(INFO) << "DecompressMessage: len=" << message->payload()->Length()
-              << " max=" << args.max_recv_message_length.value_or(-1)
-              << " alg=" << args.algorithm;
-  }
+  GRPC_TRACE_LOG(compression, INFO)
+      << "DecompressMessage: len=" << message->payload()->Length()
+      << " max=" << args.max_recv_message_length.value_or(-1)
+      << " alg=" << args.algorithm;
   auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordReceivedMessage(*message->payload());

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -139,10 +139,8 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
 }
 
 void HttpServerFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
-  if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    LOG(INFO) << GetContext<Activity>()->DebugTag()
-              << "[http-server] Write metadata";
-  }
+  GRPC_TRACE_LOG(call, INFO)
+      << GetContext<Activity>()->DebugTag() << "[http-server] Write metadata";
   FilterOutgoingMetadata(&md);
   md.Set(HttpStatusMetadata(), 200);
   md.Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -159,11 +159,10 @@ ServerMetadataHandle CheckPayload(const Message& msg,
                                   absl::optional<uint32_t> max_length,
                                   bool is_client, bool is_send) {
   if (!max_length.has_value()) return nullptr;
-  if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    LOG(INFO) << GetContext<Activity>()->DebugTag() << "[message_size] "
-              << (is_send ? "send" : "recv")
-              << " len:" << msg.payload()->Length() << " max:" << *max_length;
-  }
+  GRPC_TRACE_LOG(call, INFO)
+      << GetContext<Activity>()->DebugTag() << "[message_size] "
+      << (is_send ? "send" : "recv") << " len:" << msg.payload()->Length()
+      << " max:" << *max_length;
   if (msg.payload()->Length() <= *max_length) return nullptr;
   return ServerMetadataFromStatus(
       GRPC_STATUS_RESOURCE_EXHAUSTED,
@@ -189,12 +188,12 @@ ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
     if (config_from_call_context->max_send_size().has_value() &&
         (!max_send_size.has_value() ||
          *config_from_call_context->max_send_size() < *max_send_size)) {
-      max_send_size = *config_from_call_context->max_send_size();
+      max_send_size = config_from_call_context->max_send_size();
     }
     if (config_from_call_context->max_recv_size().has_value() &&
         (!max_recv_size.has_value() ||
          *config_from_call_context->max_recv_size() < *max_recv_size)) {
-      max_recv_size = *config_from_call_context->max_recv_size();
+      max_recv_size = config_from_call_context->max_recv_size();
     }
     limits_ = MessageSizeParsedConfig(max_send_size, max_recv_size);
   }

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -37,8 +37,6 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"