grpc 1.82.0 → 1.83.0.pre1

data/include/grpc/grpc_audit_logging.h

@@ -78,11 +78,11 @@ class AuditLoggerFactory {
   virtual ~AuditLoggerFactory() = default;
   virtual absl::string_view name() const = 0;
 
-  virtual absl::StatusOr<std::unique_ptr<Config>> ParseAuditLoggerConfig(
+  virtual absl::StatusOr<std::shared_ptr<const Config>> ParseAuditLoggerConfig(
       const Json& json) = 0;
 
   virtual std::unique_ptr<AuditLogger> CreateAuditLogger(
-      std::unique_ptr<AuditLoggerFactory::Config>) = 0;
+      std::shared_ptr<const Config> config) = 0;
 };
 
 // Registers an audit logger factory. This should only be called during

data/include/grpc/grpc_security_constants.h

@@ -155,6 +155,8 @@ typedef enum {
   GRPC_TLS_GROUP_X25519,
   /** X25519_MLKEM768 hybrid key exchange. Post-quantum cryptography. */
   GRPC_TLS_GROUP_X25519_MLKEM768,
+  /** secp384r1 ECDH key exchange. */
+  GRPC_TLS_GROUP_SECP384R1,
 } grpc_tls_key_exchange_group;
 
 #ifdef __cplusplus

data/include/grpc/impl/channel_arg_names.h

@@ -120,6 +120,22 @@
     before the request is cancelled */
 #define GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS \
   "grpc.server_max_unrequested_time_in_server"
+/** The soft limit on the number of pending requests in the server. Int valued.
+ *  If the number of pending queued requests exceeds this soft limit, then the
+ *  server will start to probabilistically reject new incoming requests up until
+ *  the hard limit. Defaults to 1000.
+ *  Note: It is not recommended to change this value unless the operational
+ *  implications are fully understood.
+ */
+#define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS "grpc.server.max_pending_requests"
+/** The hard limit on the number of pending requests in the server. Int valued.
+ *  If the number of pending queued requests reaches this hard limit, all new
+ *  incoming requests will be rejected. Defaults to 3000.
+ *  Note: It is not recommended to change this value unless the operational
+ *  implications are fully understood.
+ */
+#define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
+  "grpc.server.max_pending_requests_hard_limit"
 /** Channel arg to override the http2 :scheme header. String valued. */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a data/header
@@ -441,7 +457,14 @@
 /** \} */
 /** If non-zero, enable TCP tracing and stats collection. */
 #define GRPC_ARG_TCP_TRACING_ENABLED "grpc.tcp_tracing_enabled"
+/* Enable tracing full buffer payloads for TCP telemetry. */
+#define GRPC_ARG_TCP_TRACE_FULL_BUFFER "grpc.experimental.tcp_trace_full_buffer"
 /** Server config fetcher. */
 #define GRPC_ARG_SERVER_CONFIG_FETCHER "grpc.server_config_fetcher"
+/** Set the maximum size of a security frame that can be received on a HTTP2
+ * Connection. Check file core/ext/transport/chttp2/transport/frame.cc for
+ * details on the Security Frame.
+ */
+#define GRPC_ARG_MAX_SECURITY_FRAME_SIZE "grpc.http2.max_security_frame_size"
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/src/core/call/call_filters.h

@@ -1976,7 +1976,11 @@ class CallFilters {
   // Returns a promise that resolves to a StatusFlag indicating success
   StatusFlag PushServerInitialMetadata(ServerMetadataHandle md) {
     push_server_initial_metadata_ = std::move(md);
-    return call_state_.PushServerInitialMetadata();
+    auto flag = call_state_.PushServerInitialMetadata();
+    if (!IsStatusOk(flag)) {
+      push_server_initial_metadata_ = nullptr;
+    }
+    return flag;
   }
   // Client: Fetch server initial metadata
   // Returns a promise that resolves to ValueOrFailure<ServerMetadataHandle>
@@ -2015,7 +2019,13 @@ class CallFilters {
     GRPC_DCHECK_NE(message.get(), nullptr);
     GRPC_DCHECK_EQ(push_client_to_server_message_.get(), nullptr);
     push_client_to_server_message_ = std::move(message);
-    return [this]() { return call_state_.PollPushClientToServerMessage(); };
+    return Map([this]() { return call_state_.PollPushClientToServerMessage(); },
+               [this](StatusFlag r) {
+                 if (!IsStatusOk(r)) {
+                   push_client_to_server_message_ = nullptr;
+                 }
+                 return r;
+               });
   }
   // Client: Indicate that no more messages will be sent
   void FinishClientToServerSends() { call_state_.ClientToServerHalfClose(); }
@@ -2047,7 +2057,13 @@ class CallFilters {
   GRPC_MUST_USE_RESULT auto PushServerToClientMessage(MessageHandle message) {
     call_state_.BeginPushServerToClientMessage();
     push_server_to_client_message_ = std::move(message);
-    return [this]() { return call_state_.PollPushServerToClientMessage(); };
+    return Map([this]() { return call_state_.PollPushServerToClientMessage(); },
+               [this](StatusFlag r) {
+                 if (!IsStatusOk(r)) {
+                   push_server_to_client_message_ = nullptr;
+                 }
+                 return r;
+               });
   }
   // Server: Fetch server to client message
   // Returns a promise that resolves to ServerToClientNextMessage

data/src/core/call/call_spine.h

@@ -33,6 +33,7 @@
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/prioritized_race.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/util/dual_ref_counted.h"
@@ -223,10 +224,9 @@ class CallSpine final : public Party, public channelz::DataSource {
   template <typename Promise>
   auto UntilCallCompletes(Promise&& promise) {
     using Result = PromiseResult<std::decay_t<Promise>>;
-    return PrioritizedRace(std::forward<Promise>(promise),
-                           Map(WasCancelled(), [](bool) {
-                             return FailureStatusCast<Result>(Failure{});
-                           }));
+    return Race(Map(WasCancelled(),
+                    [](bool) { return FailureStatusCast<Result>(Failure{}); }),
+                std::forward<Promise>(promise));
   }
 
   template <typename PromiseFactory>

data/src/core/call/client_call.cc

@@ -443,7 +443,7 @@ void ClientCall::OnReceivedStatus(ServerMetadataHandle server_trailing_metadata,
                           .value_or(GRPC_STATUS_UNKNOWN);
   *out_status = status;
   Slice message_slice;
-  if (!IsErrorFlattenEnabled() || status != GRPC_STATUS_OK) {
+  if (status != GRPC_STATUS_OK) {
     if (Slice* message =
             server_trailing_metadata->get_pointer(GrpcMessageMetadata())) {
       message_slice = message->Ref();

data/src/core/call/metadata.cc

@@ -37,10 +37,15 @@ ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
 absl::Status ServerMetadataToStatus(ServerMetadata& md) {
   const auto grpc_status =
       md.get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
+  if (grpc_status == GRPC_STATUS_OK) {
+    return absl::OkStatus();
+  }
   const auto* error_slice = md.get_pointer(GrpcMessageMetadata());
+  absl::string_view message = error_slice != nullptr
+                                  ? error_slice->as_string_view()
+                                  : absl::string_view();
   return grpc_error_set_int(
-      absl::Status(static_cast<absl::StatusCode>(grpc_status),
-                   error_slice->as_string_view()),
+      absl::Status(static_cast<absl::StatusCode>(grpc_status), message),
       StatusIntProperty::kRpcStatus, grpc_status);
 }
 

data/src/core/call/server_call.cc

@@ -101,6 +101,18 @@ grpc_call_error ValidateServerBatch(const grpc_op* ops, size_t nops) {
 
 }  // namespace
 
+absl::string_view ServerCall::GetServerAuthority() const {
+  GRPC_DCHECK(client_initial_metadata_stored_ != nullptr);
+  if (client_initial_metadata_stored_ != nullptr) {
+    const Slice* authority_metadata =
+        client_initial_metadata_stored_->get_pointer(HttpAuthorityMetadata());
+    if (authority_metadata != nullptr) {
+      return authority_metadata->as_string_view();
+    }
+  }
+  return "";
+}
+
 grpc_call_error ServerCall::StartBatch(const grpc_op* ops, size_t nops,
                                        void* notify_tag,
                                        bool is_notify_tag_closure) {
@@ -246,15 +258,13 @@ grpc_call* MakeServerCall(CallHandler call_handler,
                           ServerInterface* server, grpc_completion_queue* cq,
                           grpc_metadata_array* publish_initial_metadata,
                           RefCountedPtr<Arena> parent_arena) {
-  PublishMetadataArray(client_initial_metadata.get(), publish_initial_metadata,
-                       false);
   // TODO(ctiller): ideally we'd put this in the arena with the CallHandler,
   // but there's an ownership problem: CallHandler owns the arena, and so would
   // get destroyed before the base class Call destructor runs, leading to
   // UB/crash. Investigate another path.
   return (new ServerCall(std::move(client_initial_metadata),
                          std::move(call_handler), server, cq,
-                         std::move(parent_arena)))
+                         publish_initial_metadata, std::move(parent_arena)))
       ->c_ptr();
 }
 

data/src/core/call/server_call.h

@@ -63,6 +63,7 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   ServerCall(ClientMetadataHandle client_initial_metadata,
              CallHandler call_handler, ServerInterface* server,
              grpc_completion_queue* cq,
+             grpc_metadata_array* publish_initial_metadata,
              RefCountedPtr<Arena> parent_arena = nullptr)
       : Call(false,
              client_initial_metadata->get(GrpcTimeoutMetadata())
@@ -78,6 +79,9 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
       parent_ctx->arena = std::move(parent_arena);
       arena()->SetContext<ParentCallContext>(parent_ctx);
     }
+    ProcessIncomingInitialMetadata(*client_initial_metadata_stored_);
+    PublishMetadataArray(client_initial_metadata_stored_.get(),
+                         publish_initial_metadata, false);
     SourceConstructed();
   }
 
@@ -92,9 +96,7 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
   bool is_trailers_only() const override {
     Crash("is_trailers_only not implemented for server calls");
   }
-  absl::string_view GetServerAuthority() const override {
-    Crash("unimplemented");
-  }
+  absl::string_view GetServerAuthority() const override;
   grpc_call_error StartBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) override;
   void FailBatchImmediately(void* notify_tag, bool is_notify_tag_closure,

data/src/core/client_channel/backup_poller.cc

@@ -65,11 +65,6 @@ void grpc_client_channel_global_init_backup_polling() {
   g_backup_polling_disabled = grpc_core::IsEventEngineClientEnabled() &&
                               grpc_core::IsEventEngineListenerEnabled() &&
                               grpc_core::IsEventEngineDnsEnabled();
-#ifdef GRPC_PYTHON_BUILD
-  if (!grpc_core::IsEventEnginePollerForPythonEnabled()) {
-    g_backup_polling_disabled = false;
-  }
-#endif
   if (g_backup_polling_disabled) {
     return;
   }
@@ -159,21 +154,11 @@ static void g_poller_init_locked() {
   }
 }
 
-static bool g_can_poll_in_background() {
-#ifndef GRPC_PYTHON_BUILD
-  return grpc_iomgr_run_in_background();
-#else
-  // No iomgr "event_engines" (not to be confused with the new EventEngine)
-  // are able to run in background.
-  return false;
-#endif
-}
-
 void grpc_client_channel_start_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      g_can_poll_in_background()) {
+      grpc_iomgr_run_in_background()) {
     return;
   }
   gpr_mu_lock(&g_poller_mu);
@@ -193,7 +178,7 @@ void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties) {
   if (g_backup_polling_disabled ||
       g_poll_interval == grpc_core::Duration::Zero() ||
-      g_can_poll_in_background()) {
+      grpc_iomgr_run_in_background()) {
     return;
   }
   grpc_pollset_set_del_pollset(interested_parties, g_poller->pollset);

data/src/core/client_channel/client_channel.cc

@@ -404,20 +404,18 @@ void ClientChannel::SubchannelWrapper::Orphaned() {
           }
           self->client_channel_->subchannel_map_.erase(it);
         }
-        if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-          // We need to make sure that the internal subchannel gets unreffed
-          // inside of the WorkSerializer, so that updates to the local
-          // subchannel pool are properly synchronized.  To that end, we
-          // drop our ref to the internal subchannel here.  We also cancel
-          // any watchers that were not properly cancelled, in case any of
-          // them are holding a ref to the internal subchannel.
-          for (const auto& [_, watcher] : self->watcher_map_) {
-            self->subchannel_->CancelConnectivityStateWatch(watcher);
-          }
-          self->watcher_map_.clear();
-          self->data_watchers_.clear();
-          self->subchannel_.reset();
+        // We need to make sure that the internal subchannel gets unreffed
+        // inside of the WorkSerializer, so that updates to the local
+        // subchannel pool are properly synchronized.  To that end, we
+        // drop our ref to the internal subchannel here.  We also cancel
+        // any watchers that were not properly cancelled, in case any of
+        // them are holding a ref to the internal subchannel.
+        for (const auto& [_, watcher] : self->watcher_map_) {
+          self->subchannel_->CancelConnectivityStateWatch(watcher);
         }
+        self->watcher_map_.clear();
+        self->data_watchers_.clear();
+        self->subchannel_.reset();
       });
 }
 
@@ -898,10 +896,15 @@ void ClientChannel::Ping(grpc_completion_queue*, void*) {
 grpc_call* ClientChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
-    Slice path, std::optional<Slice> authority, Timestamp deadline, bool) {
+    Slice path, std::optional<Slice> authority, Timestamp deadline,
+    bool /*registered_method*/,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine());
+  if (arena_init_function.has_value()) {
+    (*arena_init_function)(arena.get());
+  }
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
                         compression_options(), std::move(arena), Ref());

data/src/core/client_channel/client_channel.h

@@ -75,7 +75,9 @@ class ClientChannel : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* /*pollset_set_alternative*/,
                         Slice path, std::optional<Slice> authority,
-                        Timestamp deadline, bool registered_method) override;
+                        Timestamp deadline, bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
 
   void StartCall(UnstartedCallHandler unstarted_handler) override;
 

data/src/core/client_channel/client_channel_filter.cc

@@ -465,20 +465,18 @@ class ClientChannelFilter::SubchannelWrapper final
             }
             chand_->subchannel_map_.erase(it);
           }
-          if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-            // We need to make sure that the internal subchannel gets unreffed
-            // inside of the WorkSerializer, so that updates to the local
-            // subchannel pool are properly synchronized.  To that end, we
-            // drop our ref to the internal subchannel here.  We also cancel
-            // any watchers that were not properly cancelled, in case any of
-            // them are holding a ref to the internal subchannel.
-            for (const auto& [_, watcher] : watcher_map_) {
-              subchannel_->CancelConnectivityStateWatch(watcher);
-            }
-            watcher_map_.clear();
-            data_watchers_.clear();
-            subchannel_.reset();
+          // We need to make sure that the internal subchannel gets unreffed
+          // inside of the WorkSerializer, so that updates to the local
+          // subchannel pool are properly synchronized.  To that end, we
+          // drop our ref to the internal subchannel here.  We also cancel
+          // any watchers that were not properly cancelled, in case any of
+          // them are holding a ref to the internal subchannel.
+          for (const auto& [_, watcher] : watcher_map_) {
+            subchannel_->CancelConnectivityStateWatch(watcher);
           }
+          watcher_map_.clear();
+          data_watchers_.clear();
+          subchannel_.reset();
           WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
         });
   }

data/src/core/client_channel/client_channel_service_config.cc

@@ -16,14 +16,12 @@
 
 #include "src/core/client_channel/client_channel_service_config.h"
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <optional>
 #include <utility>
 
+#include "src/core/config/experiment_env_var.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
-#include "src/core/util/env.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
@@ -37,19 +35,13 @@ namespace internal {
 
 namespace {
 
-bool ConnectionScalingEnabled() {
-  auto value =
-      GetEnv("GRPC_EXPERIMENTAL_MAX_CONCURRENT_STREAMS_CONNECTION_SCALING");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 class ConnectionScalingJsonArgs final : public JsonArgs {
  public:
   bool IsEnabled(absl::string_view key) const override {
-    if (key == "connection_scaling") return ConnectionScalingEnabled();
+    if (key == "connection_scaling") {
+      return IsExperimentEnvVarEnabled(
+          "GRPC_EXPERIMENTAL_MAX_CONCURRENT_STREAMS_CONNECTION_SCALING");
+    }
     return true;
   }
 };

data/src/core/client_channel/direct_channel.cc

@@ -71,10 +71,14 @@ grpc_call* DirectChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
     Slice path, std::optional<Slice> authority, Timestamp deadline,
-    bool /*registered_method*/) {
+    bool /*registered_method*/,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine_.get());
+  if (arena_init_function.has_value()) {
+    (*arena_init_function)(arena.get());
+  }
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
                         compression_options(), std::move(arena), Ref());

data/src/core/client_channel/direct_channel.h

@@ -62,7 +62,9 @@ class DirectChannel final : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* pollset_set_alternative, Slice path,
                         std::optional<Slice> authority, Timestamp deadline,
-                        bool registered_method) override;
+                        bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
   grpc_event_engine::experimental::EventEngine* event_engine() const override {
     return event_engine_.get();
   }

data/src/core/config/experiment_env_var.cc

@@ -0,0 +1,30 @@
+// Copyright 2026 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/config/experiment_env_var.h"
+
+#include "src/core/util/env.h"
+#include "src/core/util/string.h"
+
+namespace grpc_core {
+
+bool IsExperimentEnvVarEnabled(const char* name, bool default_value) {
+  auto value = GetEnv(name);
+  if (!value.has_value()) return default_value;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
+}  // namespace grpc_core

data/src/core/config/experiment_env_var.h

@@ -0,0 +1,26 @@
+// Copyright 2026 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_CONFIG_EXPERIMENT_ENV_VAR_H
+#define GRPC_SRC_CORE_CONFIG_EXPERIMENT_ENV_VAR_H
+
+namespace grpc_core {
+
+// Returns true if the specified experiment env var is enabled.
+// If the env var is not set, returns default_value.
+bool IsExperimentEnvVarEnabled(const char* name, bool default_value = false);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CONFIG_EXPERIMENT_ENV_VAR_H

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

@@ -56,8 +56,8 @@ RegionalAccessBoundaryFetcher::Create(
     std::optional<BackOff::Options> backoff_options) {
   auto uri = URI::Parse(lookup_url);
   if (!uri.ok()) {
-    LOG(WARNING) << "Invalid RegionalAccessBoundary lookup URI \"" << lookup_url
-                 << "\" (" << uri.status() << "); RAB data will not be fetched";
+    LOG(INFO) << "Invalid RegionalAccessBoundary lookup URI \"" << lookup_url
+              << "\" (" << uri.status() << "); RAB data will not be fetched";
     return nullptr;
   }
   return MakeRefCounted<RegionalAccessBoundaryFetcher>(
@@ -103,7 +103,7 @@ void RegionalAccessBoundaryFetcher::OnFetchFailure(
   if (response_body.data() != nullptr) {
     absl::StrAppend(&log_message, ", Body: ", response_body);
   }
-  LOG(WARNING) << log_message;
+  LOG(INFO) << log_message;
   next_fetch_time_ = Timestamp::Now() + backoff_.NextAttemptDelay();
   pending_request_.reset();
 }
@@ -380,9 +380,9 @@ void EmailFetcher::OnEmailFetchComplete(absl::string_view email) {
 void EmailFetcher::OnEmailFetchError(grpc_error_handle error) {
   MutexLock lock(&mu_);
   if (std::holds_alternative<OrphanablePtr<EmailRequest>>(state_)) {
-    LOG_EVERY_N_SEC(ERROR, 60) << "Regional Access Boundary fetch skipped due "
-                                  "to service account email fetch failure: "
-                               << StatusToString(error);
+    LOG_EVERY_N_SEC(INFO, 60) << "Regional Access Boundary fetch skipped due "
+                                 "to service account email fetch failure: "
+                              << StatusToString(error);
     state_ = OrphanablePtr<EmailRequest>(
         nullptr);  // Reset to allow retry on next invocation.
     next_fetch_earliest_time_ = Timestamp::Now() + backoff_.NextAttemptDelay();

data/src/core/credentials/transport/ssl/ssl_security_connector.cc

@@ -39,6 +39,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/telemetry/metrics.h"
 #include "src/core/transport/auth_context.h"
 #include "src/core/tsi/ssl_transport_security.h"
 #include "src/core/tsi/transport_security.h"
@@ -103,13 +104,19 @@ class grpc_ssl_channel_security_connector final
                        grpc_core::HandshakeManager* handshake_mgr) override {
     // Instantiate TSI handshaker.
     tsi_handshaker* tsi_hs = nullptr;
+    auto stats_plugin_group = args.GetObject<
+        grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>();
+    grpc_core::RefCountedPtr<grpc_core::CollectionScope> collection_scope =
+        stats_plugin_group != nullptr ? stats_plugin_group->GetCollectionScope()
+                                      : nullptr;
     tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
         client_handshaker_factory_,
         overridden_target_name_.empty() ? target_name_.c_str()
                                         : overridden_target_name_.c_str(),
         /*network_bio_buf_size=*/0,
         /*ssl_bio_buf_size=*/0,
-        args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS), &tsi_hs);
+        args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS),
+        std::move(collection_scope), &tsi_hs);
     if (result != TSI_OK) {
       LOG(ERROR) << "Handshaker creation failed with error "
                  << tsi_result_to_string(result);
@@ -274,9 +281,14 @@ class grpc_ssl_server_security_connector
     // Instantiate TSI handshaker.
     try_fetch_ssl_server_credentials();
     tsi_handshaker* tsi_hs = nullptr;
+    auto stats_plugin_group = args.GetObject<
+        grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>();
+    grpc_core::RefCountedPtr<grpc_core::CollectionScope> collection_scope =
+        stats_plugin_group != nullptr ? stats_plugin_group->GetCollectionScope()
+                                      : nullptr;
     tsi_result result = tsi_ssl_server_handshaker_factory_create_handshaker(
         server_handshaker_factory_, /*network_bio_buf_size=*/0,
-        /*ssl_bio_buf_size=*/0, &tsi_hs);
+        /*ssl_bio_buf_size=*/0, std::move(collection_scope), &tsi_hs);
     if (result != TSI_OK) {
       LOG(ERROR) << "Handshaker creation failed with error "
                  << tsi_result_to_string(result);