grpc 1.73.0 → 1.74.0

data/src/core/client_channel/retry_throttle.cc

@@ -18,14 +18,9 @@
 
 #include "src/core/client_channel/retry_throttle.h"
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <cstdint>
 #include <limits>
-#include <map>
-#include <string>
-#include <utility>
 
 #include "src/core/util/useful.h"
 
@@ -33,6 +28,7 @@ namespace grpc_core {
 namespace internal {
 
 namespace {
+
 template <typename T>
 T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
   T prev_value = value.load(std::memory_order_relaxed);
@@ -43,45 +39,74 @@ T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
                                         std::memory_order_relaxed));
   return new_value;
 }
+
 }  // namespace
 
 //
-// ServerRetryThrottleData
+// RetryThrottler
 //
 
-ServerRetryThrottleData::ServerRetryThrottleData(uintptr_t max_milli_tokens,
-                                                 uintptr_t milli_token_ratio,
-                                                 uintptr_t milli_tokens)
+RefCountedPtr<RetryThrottler> RetryThrottler::Create(
+    uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+    RefCountedPtr<RetryThrottler> previous) {
+  if (previous != nullptr && previous->max_milli_tokens_ == max_milli_tokens &&
+      previous->milli_token_ratio_ == milli_token_ratio) {
+    return previous;
+  }
+  // previous is null or has different parameters.  Create a new one.
+  uintptr_t initial_milli_tokens = max_milli_tokens;
+  // If there was a pre-existing entry for this server name, initialize
+  // the token count by scaling proportionately to the old data.  This
+  // ensures that if we're already throttling retries on the old scale,
+  // we will start out doing the same thing on the new one.
+  if (previous != nullptr) {
+    double token_fraction = static_cast<double>(previous->milli_tokens_) /
+                            static_cast<double>(previous->max_milli_tokens_);
+    initial_milli_tokens =
+        static_cast<uintptr_t>(token_fraction * max_milli_tokens);
+  }
+  auto throttle_data = MakeRefCounted<RetryThrottler>(
+      max_milli_tokens, milli_token_ratio, initial_milli_tokens);
+  if (previous != nullptr) previous->SetReplacement(throttle_data);
+  return throttle_data;
+}
+
+UniqueTypeName RetryThrottler::Type() {
+  static UniqueTypeName::Factory factory("retry_throttle");
+  return factory.Create();
+}
+
+RetryThrottler::RetryThrottler(uintptr_t max_milli_tokens,
+                               uintptr_t milli_token_ratio,
+                               uintptr_t milli_tokens)
     : max_milli_tokens_(max_milli_tokens),
       milli_token_ratio_(milli_token_ratio),
       milli_tokens_(milli_tokens) {}
 
-ServerRetryThrottleData::~ServerRetryThrottleData() {
-  ServerRetryThrottleData* replacement =
-      replacement_.load(std::memory_order_acquire);
+RetryThrottler::~RetryThrottler() {
+  RetryThrottler* replacement = replacement_.load(std::memory_order_acquire);
   if (replacement != nullptr) {
     replacement->Unref();
   }
 }
 
-void ServerRetryThrottleData::SetReplacement(
-    RefCountedPtr<ServerRetryThrottleData> replacement) {
+void RetryThrottler::SetReplacement(RefCountedPtr<RetryThrottler> replacement) {
   replacement_.store(replacement.release(), std::memory_order_release);
 }
 
-void ServerRetryThrottleData::GetReplacementThrottleDataIfNeeded(
-    ServerRetryThrottleData** throttle_data) {
+void RetryThrottler::GetReplacementThrottleDataIfNeeded(
+    RetryThrottler** throttle_data) {
   while (true) {
-    ServerRetryThrottleData* new_throttle_data =
+    RetryThrottler* new_throttle_data =
         (*throttle_data)->replacement_.load(std::memory_order_acquire);
     if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
 }
 
-bool ServerRetryThrottleData::RecordFailure() {
+bool RetryThrottler::RecordFailure() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We decrement milli_tokens by 1000 (1 token) for each failure.
   const uintptr_t new_value = ClampedAdd<intptr_t>(
@@ -93,9 +118,9 @@ bool ServerRetryThrottleData::RecordFailure() {
   return new_value > throttle_data->max_milli_tokens_ / 2;
 }
 
-void ServerRetryThrottleData::RecordSuccess() {
+void RetryThrottler::RecordSuccess() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We increment milli_tokens by milli_token_ratio for each success.
   ClampedAdd<intptr_t>(
@@ -105,45 +130,5 @@ void ServerRetryThrottleData::RecordSuccess() {
                                  std::numeric_limits<intptr_t>::max())));
 }
 
-//
-// ServerRetryThrottleMap
-//
-
-ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
-  static ServerRetryThrottleMap* m = new ServerRetryThrottleMap();
-  return m;
-}
-
-RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const std::string& server_name, uintptr_t max_milli_tokens,
-    uintptr_t milli_token_ratio) {
-  MutexLock lock(&mu_);
-  auto& throttle_data = map_[server_name];
-  if (throttle_data == nullptr ||
-      throttle_data->max_milli_tokens() != max_milli_tokens ||
-      throttle_data->milli_token_ratio() != milli_token_ratio) {
-    // Entry not found, or found with old parameters.  Create a new one.
-    auto old_throttle_data = std::move(throttle_data);
-    uintptr_t initial_milli_tokens = max_milli_tokens;
-    // If there was a pre-existing entry for this server name, initialize
-    // the token count by scaling proportionately to the old data.  This
-    // ensures that if we're already throttling retries on the old scale,
-    // we will start out doing the same thing on the new one.
-    if (old_throttle_data != nullptr) {
-      double token_fraction =
-          static_cast<double>(old_throttle_data->milli_tokens()) /
-          static_cast<double>(old_throttle_data->max_milli_tokens());
-      initial_milli_tokens =
-          static_cast<uintptr_t>(token_fraction * max_milli_tokens);
-    }
-    throttle_data = MakeRefCounted<ServerRetryThrottleData>(
-        max_milli_tokens, milli_token_ratio, initial_milli_tokens);
-    if (old_throttle_data != nullptr) {
-      old_throttle_data->SetReplacement(throttle_data);
-    }
-  }
-  return throttle_data;
-}
-
 }  // namespace internal
 }  // namespace grpc_core

data/src/core/client_channel/retry_throttle.h

@@ -19,30 +19,29 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <atomic>
-#include <map>
-#include <string>
 
-#include "absl/base/thread_annotations.h"
-#include "src/core/util/ref_counted.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 namespace internal {
 
-class ServerRetryThrottleMap;
-
 /// Tracks retry throttling data for an individual server name.
-class ServerRetryThrottleData final
-    : public RefCounted<ServerRetryThrottleData> {
+class RetryThrottler final : public Blackboard::Entry {
  public:
-  ServerRetryThrottleData(uintptr_t max_milli_tokens,
-                          uintptr_t milli_token_ratio, uintptr_t milli_tokens);
-  ~ServerRetryThrottleData() override;
+  static RefCountedPtr<RetryThrottler> Create(
+      uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+      RefCountedPtr<RetryThrottler> previous);
+
+  static UniqueTypeName Type();
+
+  // Do not instantiate directly -- use Create() instead.
+  RetryThrottler(uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+                 uintptr_t milli_tokens);
+  ~RetryThrottler() override;
 
   /// Records a failure.  Returns true if it's okay to send a retry.
   bool RecordFailure();
@@ -50,6 +49,7 @@ class ServerRetryThrottleData final
   /// Records a success.
   void RecordSuccess();
 
+  // Exposed for testing purposes only.
   uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
   uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
   intptr_t milli_tokens() const {
@@ -57,39 +57,17 @@ class ServerRetryThrottleData final
   }
 
  private:
-  friend ServerRetryThrottleMap;
+  void SetReplacement(RefCountedPtr<RetryThrottler> replacement);
 
-  void SetReplacement(RefCountedPtr<ServerRetryThrottleData> replacement);
-
-  void GetReplacementThrottleDataIfNeeded(
-      ServerRetryThrottleData** throttle_data);
+  void GetReplacementThrottleDataIfNeeded(RetryThrottler** throttle_data);
 
   const uintptr_t max_milli_tokens_;
   const uintptr_t milli_token_ratio_;
   std::atomic<intptr_t> milli_tokens_;
-  // A pointer to the replacement for this ServerRetryThrottleData entry.
+  // A pointer to the replacement for this RetryThrottler entry.
   // If non-nullptr, then this entry is stale and must not be used.
   // We hold a reference to the replacement.
-  std::atomic<ServerRetryThrottleData*> replacement_{nullptr};
-};
-
-/// Global map of server name to retry throttle data.
-class ServerRetryThrottleMap final {
- public:
-  static ServerRetryThrottleMap* Get();
-
-  /// Returns the failure data for \a server_name, creating a new entry if
-  /// needed.
-  RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const std::string& server_name, uintptr_t max_milli_tokens,
-      uintptr_t milli_token_ratio);
-
- private:
-  using StringToDataMap =
-      std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
-
-  Mutex mu_;
-  StringToDataMap map_ ABSL_GUARDED_BY(mu_);
+  std::atomic<RetryThrottler*> replacement_{nullptr};
 };
 
 }  // namespace internal

data/src/core/client_channel/subchannel.cc

@@ -422,11 +422,21 @@ class Subchannel::ConnectedSubchannelStateWatcher final
         if (c->channelz_node() != nullptr) {
           c->channelz_node()->SetChildSocket(nullptr);
         }
-        // Even though we're reporting IDLE instead of TRANSIENT_FAILURE here,
-        // pass along the status from the transport, since it may have
-        // keepalive info attached to it that the channel needs.
-        // TODO(roth): Consider whether there's a cleaner way to do this.
-        c->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, status);
+        // If the subchannel was created from an endpoint, then we report
+        // TRANSIENT_FAILURE here instead of IDLE. The subchannel will never
+        // leave TRANSIENT_FAILURE state, because there is no way for us to
+        // establish a new connection.
+        //
+        // Otherwise, we report IDLE here. Note that even though we're not
+        // reporting TRANSIENT_FAILURE, we pass along the status from the
+        // transport, since it may have keepalive info attached to it that the
+        // channel needs.
+        // TODO(roth): Consider whether there's a cleaner way to propagate the
+        // keepalive info.
+        c->SetConnectivityStateLocked(c->created_from_endpoint_
+                                          ? GRPC_CHANNEL_TRANSIENT_FAILURE
+                                          : GRPC_CHANNEL_IDLE,
+                                      status);
         c->backoff_.Reset();
       }
     }
@@ -509,6 +519,7 @@ Subchannel::Subchannel(SubchannelKey key,
                                      ? "Subchannel"
                                      : nullptr),
       key_(std::move(key)),
+      created_from_endpoint_(args.Contains(GRPC_ARG_SUBCHANNEL_ENDPOINT)),
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
@@ -546,9 +557,7 @@ Subchannel::Subchannel(SubchannelKey key,
         grpc_sockaddr_to_uri(&key_.address())
             .value_or("<unknown address type>"),
         channel_tracer_max_memory);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("subchannel created"));
+    GRPC_CHANNELZ_LOG(channelz_node_) << "subchannel created";
     channelz_node_->SetChannelArgs(args_);
     args_ = args_.SetObject<channelz::BaseNode>(channelz_node_);
   }
@@ -556,9 +565,7 @@ Subchannel::Subchannel(SubchannelKey key,
 
 Subchannel::~Subchannel() {
   if (channelz_node_ != nullptr) {
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Subchannel destroyed"));
+    GRPC_CHANNELZ_LOG(channelz_node_) << "Subchannel destroyed";
     channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
   }
   connector_.reset();
@@ -578,6 +585,15 @@ RefCountedPtr<Subchannel> Subchannel::Create(
     return c;
   }
   c = MakeRefCounted<Subchannel>(std::move(key), std::move(connector), args);
+  if (c->created_from_endpoint_) {
+    // We don't interact with the subchannel pool in this case.
+    // Instead, we unconditionally return the newly created subchannel.
+    // Before returning, we explicitly trigger a connection attempt
+    // by calling RequestConnection(), which sets the subchannel’s
+    // connectivity state to CONNECTING.
+    c->RequestConnection();
+    return c;
+  }
   // Try to register the subchannel before setting the subchannel pool.
   // Otherwise, in case of a registration race, unreffing c in
   // RegisterSubchannel() will cause c to be tried to be unregistered, while
@@ -702,12 +718,15 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
   }
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_cpp_string(absl::StrCat(
-            "Subchannel connectivity state changed to ",
-            ConnectivityStateName(state),
-            status.ok() ? "" : absl::StrCat(": ", status_.ToString()))));
+    if (status.ok()) {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << "Subchannel connectivity state changed to "
+          << ConnectivityStateName(state);
+    } else {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << "Subchannel connectivity state changed to "
+          << ConnectivityStateName(state) << ": " << status;
+    }
   }
   // Notify watchers.
   watcher_list_.NotifyLocked(state, status_);
@@ -767,10 +786,15 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
         next_attempt_time_ - Timestamp::Now();
     GRPC_TRACE_LOG(subchannel, INFO)
         << "subchannel " << this << " " << key_.ToString()
-        << ": connect failed (" << StatusToString(error)
-        << "), backing off for " << time_until_next_attempt.millis() << " ms";
+        << ": connect failed (" << StatusToString(error) << ")"
+        << (created_from_endpoint_
+                ? ", no retry will be attempted (created from endpoint); "
+                  "remaining in TRANSIENT_FAILURE"
+                : ", backing off for " +
+                      std::to_string(time_until_next_attempt.millis()) + " ms");
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
+    if (created_from_endpoint_) return;
     retry_timer_handle_ = event_engine_->RunAfter(
         time_until_next_attempt,
         [self = WeakRef(DEBUG_LOCATION, "RetryTimer")]() mutable {

data/src/core/client_channel/subchannel.h

@@ -58,6 +58,11 @@
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/work_serializer.h"
 
+/** This arg is intended for internal use only, primarily
+ *  for passing endpoint information during subchannel creation or connection.
+ */
+#define GRPC_ARG_SUBCHANNEL_ENDPOINT "grpc.internal.subchannel_endpoint"
+
 namespace grpc_core {
 
 class SubchannelCall;
@@ -328,6 +333,9 @@ class Subchannel final : public DualRefCounted<Subchannel> {
   RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
   // Subchannel key that identifies this subchannel in the subchannel pool.
   const SubchannelKey key_;
+  // boolean value that identifies this subchannel is created from event engine
+  // endpoint.
+  const bool created_from_endpoint_;
   // Actual address to connect to.  May be different than the address in
   // key_ if overridden by proxy mapper.
   grpc_resolved_address address_for_connect_;

data/src/core/config/config_vars.cc

@@ -30,7 +30,9 @@
 #endif  // !GPR_DEFAULT_LOG_VERBOSITY_STRING
 
 #ifdef GRPC_ENABLE_FORK_SUPPORT
+#ifndef GRPC_ENABLE_FORK_SUPPORT_DEFAULT
 #define GRPC_ENABLE_FORK_SUPPORT_DEFAULT true
+#endif  // !defined(GRPC_ENABLE_FORK_SUPPORT_DEFAULT)
 #else
 #define GRPC_ENABLE_FORK_SUPPORT_DEFAULT false
 #endif  // GRPC_ENABLE_FORK_SUPPORT

data/src/core/config/core_configuration.cc

@@ -43,6 +43,7 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
       channel_init_(builder->channel_init_.Build()),
       handshaker_registry_(builder->handshaker_registry_.Build()),
       channel_creds_registry_(builder->channel_creds_registry_.Build()),
+      call_creds_registry_(builder->call_creds_registry_.Build()),
       service_config_parser_(builder->service_config_parser_.Build()),
       resolver_registry_(builder->resolver_registry_.Build()),
       lb_policy_registry_(builder->lb_policy_registry_.Build()),

data/src/core/config/core_configuration.h

@@ -22,6 +22,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "src/core/credentials/call/call_creds_registry.h"
 #include "src/core/credentials/transport/channel_creds_registry.h"
 #include "src/core/credentials/transport/tls/certificate_provider_registry.h"
 #include "src/core/handshaker/handshaker_registry.h"
@@ -82,6 +83,10 @@ class GRPC_DLL CoreConfiguration {
       return &channel_creds_registry_;
     }
 
+    CallCredsRegistry<>::Builder* call_creds_registry() {
+      return &call_creds_registry_;
+    }
+
     ServiceConfigParser::Builder* service_config_parser() {
       return &service_config_parser_;
     }
@@ -113,6 +118,7 @@ class GRPC_DLL CoreConfiguration {
     ChannelInit::Builder channel_init_;
     HandshakerRegistry::Builder handshaker_registry_;
     ChannelCredsRegistry<>::Builder channel_creds_registry_;
+    CallCredsRegistry<>::Builder call_creds_registry_;
     ServiceConfigParser::Builder service_config_parser_;
     ResolverRegistry::Builder resolver_registry_;
     LoadBalancingPolicyRegistry::Builder lb_policy_registry_;
@@ -241,6 +247,10 @@ class GRPC_DLL CoreConfiguration {
     return channel_creds_registry_;
   }
 
+  const CallCredsRegistry<>& call_creds_registry() const {
+    return call_creds_registry_;
+  }
+
   const ServiceConfigParser& service_config_parser() const {
     return service_config_parser_;
   }
@@ -292,6 +302,7 @@ class GRPC_DLL CoreConfiguration {
   ChannelInit channel_init_;
   HandshakerRegistry handshaker_registry_;
   ChannelCredsRegistry<> channel_creds_registry_;
+  CallCredsRegistry<> call_creds_registry_;
   ServiceConfigParser service_config_parser_;
   ResolverRegistry resolver_registry_;
   LoadBalancingPolicyRegistry lb_policy_registry_;

data/src/core/credentials/call/call_creds_registry.h

@@ -0,0 +1,125 @@
+//
+// Copyright 2025 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_CREDENTIALS_CALL_CALL_CREDS_REGISTRY_H
+#define GRPC_SRC_CORE_CREDENTIALS_CALL_CALL_CREDS_REGISTRY_H
+
+#include <map>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/validation_errors.h"
+
+struct grpc_call_credentials;
+
+namespace grpc_core {
+
+class CallCredsConfig : public RefCounted<CallCredsConfig> {
+ public:
+  virtual absl::string_view type() const = 0;
+
+  virtual bool Equals(const CallCredsConfig& other) const = 0;
+
+  virtual std::string ToString() const = 0;
+};
+
+template <typename T = grpc_call_credentials>
+class CallCredsFactory final {
+ public:
+  virtual ~CallCredsFactory() {}
+  virtual absl::string_view type() const = delete;
+  virtual RefCountedPtr<CallCredsConfig> ParseConfig(
+      const Json& config, const JsonArgs& args,
+      ValidationErrors* errors) const = delete;
+  virtual RefCountedPtr<T> CreateCallCreds(
+      RefCountedPtr<CallCredsConfig> config) const = delete;
+};
+
+template <>
+class CallCredsFactory<grpc_call_credentials> {
+ public:
+  virtual ~CallCredsFactory() {}
+  virtual absl::string_view type() const = 0;
+  virtual RefCountedPtr<CallCredsConfig> ParseConfig(
+      const Json& config, const JsonArgs& args,
+      ValidationErrors* errors) const = 0;
+  virtual RefCountedPtr<grpc_call_credentials> CreateCallCreds(
+      RefCountedPtr<CallCredsConfig> config) const = 0;
+};
+
+template <typename T = grpc_call_credentials>
+class CallCredsRegistry {
+ private:
+  using FactoryMap =
+      std::map<absl::string_view, std::unique_ptr<CallCredsFactory<T>>>;
+
+ public:
+  static_assert(std::is_base_of<grpc_call_credentials, T>::value,
+                "CallCredsRegistry must be instantiated with "
+                "grpc_call_credentials.");
+
+  class Builder {
+   public:
+    void RegisterCallCredsFactory(
+        std::unique_ptr<CallCredsFactory<T>> factory) {
+      absl::string_view type = factory->type();
+      factories_[type] = std::move(factory);
+    }
+    CallCredsRegistry Build() {
+      return CallCredsRegistry<T>(std::move(factories_));
+    }
+
+   private:
+    FactoryMap factories_;
+  };
+
+  bool IsSupported(absl::string_view type) const {
+    return factories_.find(type) != factories_.end();
+  }
+
+  RefCountedPtr<CallCredsConfig> ParseConfig(absl::string_view type,
+                                             const Json& config,
+                                             const JsonArgs& args,
+                                             ValidationErrors* errors) const {
+    const auto it = factories_.find(type);
+    if (it == factories_.cend()) return nullptr;
+    return it->second->ParseConfig(config, args, errors);
+  }
+
+  RefCountedPtr<T> CreateCallCreds(
+      RefCountedPtr<CallCredsConfig> config) const {
+    if (config == nullptr) return nullptr;
+    const auto it = factories_.find(config->type());
+    if (it == factories_.cend()) return nullptr;
+    return it->second->CreateCallCreds(std::move(config));
+  }
+
+ private:
+  explicit CallCredsRegistry(FactoryMap factories)
+      : factories_(std::move(factories)) {}
+
+  FactoryMap factories_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CREDENTIALS_CALL_CALL_CREDS_REGISTRY_H

data/src/core/credentials/call/call_creds_registry_init.cc

@@ -0,0 +1,91 @@
+//
+// Copyright 2025 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/credentials.h>
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/json.h>
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "src/core/config/core_configuration.h"
+#include "src/core/credentials/call/call_credentials.h"
+#include "src/core/credentials/call/call_creds_registry.h"
+#include "src/core/credentials/call/jwt_token_file/jwt_token_file_call_credentials.h"
+#include "src/core/util/down_cast.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"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/validation_errors.h"
+
+namespace grpc_core {
+
+class JwtTokenFileCallCredsFactory : public CallCredsFactory<> {
+ public:
+  absl::string_view type() const override { return Type(); }
+
+  RefCountedPtr<CallCredsConfig> ParseConfig(
+      const Json& config, const JsonArgs& args,
+      ValidationErrors* errors) const override {
+    return LoadFromJson<RefCountedPtr<Config>>(config, args, errors);
+  }
+
+  RefCountedPtr<grpc_call_credentials> CreateCallCreds(
+      RefCountedPtr<CallCredsConfig> base_config) const override {
+    auto* config = DownCast<const Config*>(base_config.get());
+    return MakeRefCounted<JwtTokenFileCallCredentials>(config->path());
+  }
+
+ private:
+  class Config : public CallCredsConfig {
+   public:
+    absl::string_view type() const override { return Type(); }
+
+    bool Equals(const CallCredsConfig& other) const override {
+      auto& o = DownCast<const Config&>(other);
+      return path_ == o.path_;
+    }
+
+    std::string ToString() const override {
+      return absl::StrCat("{path=\"", path_, "\"}");
+    }
+
+    const std::string& path() const { return path_; }
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader = JsonObjectLoader<Config>()
+                                      .Field("jwt_token_file", &Config::path_)
+                                      .Finish();
+      return loader;
+    }
+
+   private:
+    std::string path_;
+  };
+
+  static absl::string_view Type() { return "jwt_token_file"; }
+};
+
+void RegisterDefaultCallCreds(CoreConfiguration::Builder* builder) {
+  builder->call_creds_registry()->RegisterCallCredsFactory(
+      std::make_unique<JwtTokenFileCallCredsFactory>());
+}
+
+}  // namespace grpc_core