grpc 1.72.0 → 1.73.0

data/src/core/load_balancing/xds/xds_override_host.cc

@@ -286,6 +286,15 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
       address_list_ = std::move(address_list);
     }
 
+    const ChannelArgs& per_endpoint_args() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return per_endpoint_args_;
+    }
+    void set_per_endpoint_args(ChannelArgs per_endpoint_args)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      per_endpoint_args_ = std::move(per_endpoint_args);
+    }
+
     Timestamp last_used_time() const
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
       return last_used_time_;
@@ -304,6 +313,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
         &XdsOverrideHostLb::mu_) = XdsHealthStatus(XdsHealthStatus::kUnknown);
     RefCountedStringValue address_list_
         ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
+    ChannelArgs per_endpoint_args_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
     Timestamp last_used_time_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) =
         Timestamp::InfPast();
   };
@@ -319,30 +329,6 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
     PickResult Pick(PickArgs args) override;
 
    private:
-    class SubchannelConnectionRequester final {
-     public:
-      explicit SubchannelConnectionRequester(
-          RefCountedPtr<SubchannelWrapper> subchannel)
-          : subchannel_(std::move(subchannel)) {
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        // Hop into ExecCtx, so that we don't get stuck running
-        // arbitrary WorkSerializer callbacks while doing a pick.
-        ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-      }
-
-     private:
-      static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<SubchannelConnectionRequester*>(arg);
-        self->subchannel_->policy()->work_serializer()->Run([self]() {
-          self->subchannel_->RequestConnection();
-          delete self;
-        });
-      }
-
-      RefCountedPtr<SubchannelWrapper> subchannel_;
-      grpc_closure closure_;
-    };
-
     std::optional<LoadBalancingPolicy::PickResult> PickOverriddenHost(
         XdsOverrideHostAttribute* override_host_attr) const;
 
@@ -493,7 +479,10 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
     GRPC_TRACE_LOG(xds_override_host_lb, INFO)
         << "Picker override found IDLE subchannel";
     // Deletes itself after the connection is requested.
-    new SubchannelConnectionRequester(std::move(idle_subchannel));
+    policy_->work_serializer()->Run(
+        [subchannel = std::move(idle_subchannel)]() {
+          subchannel->RequestConnection();
+        });
     return PickResult::Queue();
   }
   // No READY or IDLE subchannels.  If we found a CONNECTING subchannel,
@@ -793,8 +782,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
   struct AddressInfo {
     XdsHealthStatus eds_health_status;
     RefCountedStringValue address_list;
-    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses)
-        : eds_health_status(status), address_list(std::move(addresses)) {}
+    ChannelArgs per_endpoint_args;
+    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses,
+                ChannelArgs args)
+        : eds_health_status(status),
+          address_list(std::move(addresses)),
+          per_endpoint_args(std::move(args)) {}
   };
   std::map<const std::string, AddressInfo> addresses_for_map;
   endpoints.ForEach([&](const EndpointAddresses& endpoint) {
@@ -830,7 +823,8 @@ void XdsOverrideHostLb::UpdateAddressMap(
                        (end.empty() ? "" : ","), end));
       addresses_for_map.emplace(
           std::piecewise_construct, std::forward_as_tuple(addresses[i]),
-          std::forward_as_tuple(status, std::move(address_list)));
+          std::forward_as_tuple(status, std::move(address_list),
+                                endpoint.args()));
     }
   });
   // Now grab the lock and update subchannel_map_ from addresses_for_map.
@@ -865,9 +859,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
           << "[xds_override_host_lb " << this << "] map key " << address
           << ": setting "
           << "eds_health_status=" << address_info.eds_health_status.ToString()
-          << " address_list=" << address_info.address_list.c_str();
+          << " address_list=" << address_info.address_list.c_str()
+          << " per_endpoint_args=" << address_info.per_endpoint_args.ToString();
       it->second->set_eds_health_status(address_info.eds_health_status);
       it->second->set_address_list(std::move(address_info.address_list));
+      it->second->set_per_endpoint_args(
+          std::move(address_info.per_endpoint_args));
       // Check the entry's last_used_time to determine the next time at
       // which the timer needs to run.
       if (it->second->last_used_time() > idle_threshold) {
@@ -908,14 +905,38 @@ void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
       << address;
   auto addr = StringToSockaddr(address);
   CHECK(addr.ok());
-  // Note: We don't currently have any cases where per_address_args need to
-  // be passed through.  If we encounter any such cases in the future, we
-  // will need to change this to store those attributes from the resolver
-  // update in the map entry.
+  // We need to do 3 things here:
+  // 1. Get the per-endpoint args from the entry in subchannel_map_.
+  // 2. Create the subchannel using those per-endpoint args.
+  // 3. Wrap the subchannel and store the wrapper in subchannel_map_.
+  //
+  // Steps 1 and 3 require holding the lock, but we don't want to hold
+  // the lock in step 2, since we're calling into arbitrary code in the
+  // channel.  Unfortunately, this means we need to grab and release the
+  // lock twice -- and each time, we need to check if some other thread
+  // has preempted us.
+  //
+  // Step 1.
+  ChannelArgs per_endpoint_args;
+  {
+    MutexLock lock(&mu_);
+    auto it = subchannel_map_.find(address);
+    // This can happen if the map entry was removed between the time that
+    // the picker requested the subchannel creation and the time that we got
+    // here.  In that case, we can just make it a no-op, since the update
+    // that removed the entry will have generated a new picker already.
+    if (it == subchannel_map_.end()) return;
+    // This can happen if the picker requests subchannel creation for
+    // the same address multiple times.
+    if (it->second->HasOwnedSubchannel()) return;
+    per_endpoint_args = it->second->per_endpoint_args();
+  }
+  // Step 2.
   auto subchannel = channel_control_helper()->CreateSubchannel(
-      *addr, /*per_address_args=*/ChannelArgs(), args_);
+      *addr, per_endpoint_args, args_);
   auto wrapper = MakeRefCounted<SubchannelWrapper>(
       std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
+  // Step 3.
   {
     MutexLock lock(&mu_);
     auto it = subchannel_map_.find(address);

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -70,6 +70,7 @@ extern void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 extern void RegisterConnectedChannel(CoreConfiguration::Builder* builder);
 extern void RegisterLoadBalancedCallDestination(
     CoreConfiguration::Builder* builder);
+extern void RegisterChttp2Transport(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
 #endif  // !GRPC_NO_RLS
@@ -98,6 +99,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterEndpointInfoHandshaker(builder);
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
+  RegisterChttp2Transport(builder);
   RegisterPriorityLbPolicy(builder);
   RegisterOutlierDetectionLbPolicy(builder);
   RegisterWeightedTargetLbPolicy(builder);

data/src/core/resolver/sockaddr/sockaddr_resolver.cc

@@ -86,7 +86,8 @@ bool ParseUri(const URI& uri,
       // Skip targets which are empty.
       continue;
     }
-    auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
+    auto ith_uri = URI::Create(uri.scheme(), /*user_info=*/"", /*host_port=*/"",
+                               std::string(ith_path), {}, "");
     grpc_resolved_address addr;
     if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
       errors_found = true;

data/src/core/resolver/xds/xds_resolver.cc

@@ -78,6 +78,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
@@ -690,7 +691,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
           XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
           /*weighted_clusters*/) {
         const uint32_t key = absl::Uniform<uint32_t>(
-            absl::BitGen(), 0, entry->weighted_cluster_state.back().range_end);
+            SharedBitGen(), 0, entry->weighted_cluster_state.back().range_end);
         // Find the index in weighted clusters corresponding to key.
         size_t mid = 0;
         size_t start_index = 0;

data/src/core/server/add_port.cc

@@ -0,0 +1,87 @@
+// 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/grpc.h>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/transport_credentials.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/server/server.h"
+
+// TODO(ctiller): rename to grpc_server_add_listener_port.
+int grpc_server_add_http2_port(grpc_server* server, const char* addr,
+                               grpc_server_credentials* creds) {
+  grpc_core::ExecCtx exec_ctx;
+  grpc_core::RefCountedPtr<grpc_server_security_connector> sc;
+  grpc_core::Server* core_server = grpc_core::Server::FromC(server);
+  grpc_core::ChannelArgs args = core_server->channel_args();
+  GRPC_TRACE_LOG(api, INFO) << "grpc_server_add_http2_port(server=" << server
+                            << ", addr=" << addr << ", creds=" << creds << ")";
+  if (creds == nullptr) {
+    LOG(ERROR)
+        << "Failed to add port to server: No credentials specified for secure "
+           "server port (creds==NULL)";
+    return 0;
+  }
+  // TODO(yashykt): Ideally, we would not want to have different behavior here
+  // based on whether a config fetcher is configured or not. Currently, we have
+  // a feature for SSL credentials reloading with an application callback that
+  // assumes that there is a single security connector. If we delay the creation
+  // of the security connector to after the creation of the listener(s), we
+  // would have potentially multiple security connectors which breaks the
+  // assumption for SSL creds reloading. When the API for SSL creds reloading is
+  // rewritten, we would be able to make this workaround go away by removing
+  // that assumption. As an immediate drawback of this workaround, config
+  // fetchers need to be registered before adding ports to the server.
+  if (core_server->config_fetcher() != nullptr) {
+    // Create channel args.
+    args = args.SetObject(creds->Ref());
+  } else {
+    sc = creds->create_security_connector(grpc_core::ChannelArgs());
+    if (sc == nullptr) {
+      LOG(ERROR) << "Unable to create secure server with credentials of type ",
+          creds->type().name();
+      return 0;
+    }
+    args = args.SetObject(creds->Ref()).SetObject(sc);
+  }
+  std::vector<absl::string_view> transport_preferences = absl::StrSplit(
+      args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS).value_or("h2"),
+      ',');
+  if (transport_preferences.size() != 1) {
+    LOG(ERROR) << "Failed to add port to server: "
+                  "Only one preferred transport name is currently supported: "
+                  "requested='"
+               << *args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS)
+               << "'";
+    return 0;
+  }
+  auto* transport = grpc_core::CoreConfiguration::Get()
+                        .endpoint_transport_registry()
+                        .GetTransport(transport_preferences[0]);
+  if (transport == nullptr) {
+    LOG(ERROR) << "Failed to add port to server: unknown protocol '"
+               << transport_preferences[0] << "'";
+    return 0;
+  }
+  auto r = transport->AddPort(core_server, addr, args);
+  if (!r.ok()) {
+    LOG(ERROR) << "Failed to add port to server: " << r.status().message();
+    return 0;
+  }
+  return *r;
+}

data/src/core/server/server.cc

@@ -81,6 +81,7 @@
 #include "src/core/util/debug_location.h"
 #include "src/core/util/mpscq.h"
 #include "src/core/util/orphanable.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/useful.h"
 
@@ -140,41 +141,35 @@ Server::ListenerState::ListenerState(RefCountedPtr<Server> server,
 }
 
 void Server::ListenerState::Start() {
-  if (IsServerListenerEnabled()) {
-    if (server_->config_fetcher() != nullptr) {
-      auto watcher = std::make_unique<ConfigFetcherWatcher>(this);
-      config_fetcher_watcher_ = watcher.get();
-      server_->config_fetcher()->StartWatch(
-          grpc_sockaddr_to_string(listener_->resolved_address(), false).value(),
-          std::move(watcher));
-    } else {
-      {
-        MutexLock lock(&mu_);
-        started_ = true;
-        is_serving_ = true;
-      }
-      listener_->Start();
-    }
+  if (server_->config_fetcher() != nullptr) {
+    auto watcher = std::make_unique<ConfigFetcherWatcher>(this);
+    config_fetcher_watcher_ = watcher.get();
+    server_->config_fetcher()->StartWatch(
+        grpc_sockaddr_to_string(listener_->resolved_address(), false).value(),
+        std::move(watcher));
   } else {
+    {
+      MutexLock lock(&mu_);
+      started_ = true;
+      is_serving_ = true;
+    }
     listener_->Start();
   }
 }
 
 void Server::ListenerState::Stop() {
-  if (IsServerListenerEnabled()) {
-    absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
-        connections;
-    {
-      MutexLock lock(&mu_);
-      // Orphan the connections so that they can start cleaning up.
-      connections = std::move(connections_);
-      connections_.clear();
-      is_serving_ = false;
-    }
-    if (config_fetcher_watcher_ != nullptr) {
-      CHECK_NE(server_->config_fetcher(), nullptr);
-      server_->config_fetcher()->CancelWatch(config_fetcher_watcher_);
-    }
+  absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
+      connections;
+  {
+    MutexLock lock(&mu_);
+    // Orphan the connections so that they can start cleaning up.
+    connections = std::move(connections_);
+    connections_.clear();
+    is_serving_ = false;
+  }
+  if (config_fetcher_watcher_ != nullptr) {
+    CHECK_NE(server_->config_fetcher(), nullptr);
+    server_->config_fetcher()->CancelWatch(config_fetcher_watcher_);
   }
   GRPC_CLOSURE_INIT(&destroy_done_, ListenerDestroyDone, server_.get(),
                     grpc_schedule_on_exec_ctx);
@@ -732,7 +727,7 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       }
       if (rc == nullptr) {
         if (server_->pending_backlog_protector_.Reject(pending_promises_.size(),
-                                                       server_->bitgen_)) {
+                                                       SharedBitGen())) {
           return Immediate(absl::ResourceExhaustedError(
               "Too many pending requests for this server"));
         }
@@ -1068,6 +1063,7 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
     channelz_node->AddTraceEvent(
         channelz::ChannelTrace::Severity::Info,
         grpc_slice_from_static_string("Server created"));
+    channelz_node->SetChannelArgs(args);
   }
   return channelz_node;
 }
@@ -1197,8 +1193,7 @@ void Server::AddListener(OrphanablePtr<ListenerInterface> listener) {
   channelz::ListenSocketNode* listen_socket_node =
       listener->channelz_listen_socket_node();
   if (listen_socket_node != nullptr && channelz_node_ != nullptr) {
-    channelz_node_->AddChildListenSocket(
-        listen_socket_node->RefAsSubclass<channelz::ListenSocketNode>());
+    listen_socket_node->AddParent(channelz_node_.get());
   }
   ListenerInterface* ptr = listener.get();
   listener_states_.emplace_back(
@@ -1243,10 +1238,9 @@ void Server::Start() {
   starting_cv_.Signal();
 }
 
-grpc_error_handle Server::SetupTransport(
-    Transport* transport, grpc_pollset* accepting_pollset,
-    const ChannelArgs& args,
-    const RefCountedPtr<channelz::SocketNode>& socket_node) {
+grpc_error_handle Server::SetupTransport(Transport* transport,
+                                         grpc_pollset* accepting_pollset,
+                                         const ChannelArgs& args) {
   GRPC_LATENT_SEE_INNER_SCOPE("Server::SetupTransport");
   // Create channel.
   global_stats().IncrementServerChannelsCreated();
@@ -1256,11 +1250,12 @@ grpc_error_handle Server::SetupTransport(
     // TODO(ctiller): post-v3-transition make this method take an
     // OrphanablePtr<ServerTransport> directly.
     OrphanablePtr<ServerTransport> t(transport->server_transport());
-    auto destination = MakeCallDestination(args.SetObject(transport));
+    auto destination = MakeCallDestination(
+        args.SetObject(transport).SetObject<channelz::BaseNode>(
+            transport->GetSocketNode()));
     if (!destination.ok()) {
       return absl_status_to_grpc_error(destination.status());
     }
-    // TODO(ctiller): add channelz node
     t->SetCallDestination(std::move(*destination));
     MutexLock lock(&mu_global_);
     if (ShutdownCalled()) {
@@ -1268,13 +1263,19 @@ grpc_error_handle Server::SetupTransport(
     }
     t->StartConnectivityWatch(MakeOrphanable<TransportConnectivityWatcher>(
         t->RefAsSubclass<ServerTransport>(), Ref()));
+    if (auto socket_node = transport->GetSocketNode(); socket_node != nullptr) {
+      socket_node->AddParent(channelz_node_.get());
+    }
     GRPC_TRACE_LOG(server_channel, INFO) << "Adding connection";
     connections_.emplace(std::move(t));
     ++connections_open_;
   } else {
     CHECK(transport->filter_stack_transport() != nullptr);
     absl::StatusOr<RefCountedPtr<Channel>> channel = LegacyChannel::Create(
-        "", args.SetObject(transport), GRPC_SERVER_CHANNEL);
+        "",
+        args.SetObject(transport).SetObject<channelz::BaseNode>(
+            transport->GetSocketNode()),
+        GRPC_SERVER_CHANNEL);
     if (!channel.ok()) {
       return absl_status_to_grpc_error(channel.status());
     }
@@ -1293,9 +1294,9 @@ grpc_error_handle Server::SetupTransport(
       cq_idx = static_cast<size_t>(rand()) % std::max<size_t>(1, cqs_.size());
     }
     intptr_t channelz_socket_uuid = 0;
-    if (socket_node != nullptr) {
+    if (auto socket_node = transport->GetSocketNode(); socket_node != nullptr) {
       channelz_socket_uuid = socket_node->uuid();
-      channelz_node_->AddChildSocket(socket_node);
+      socket_node->AddParent(channelz_node_.get());
     }
     // Initialize chand.
     chand->InitTransport(Ref(), std::move(*channel), cq_idx, transport,
@@ -1496,8 +1497,7 @@ void Server::StopListening() {
     channelz::ListenSocketNode* channelz_listen_socket_node =
         listener_state->listener()->channelz_listen_socket_node();
     if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
-      channelz_node_->RemoveChildListenSocket(
-          channelz_listen_socket_node->uuid());
+      channelz_listen_socket_node->RemoveParent(channelz_node_.get());
     }
     listener_state->Stop();
   }
@@ -1649,17 +1649,12 @@ class Server::ChannelData::ConnectivityWatcher
 
 Server::ChannelData::~ChannelData() {
   if (server_ != nullptr) {
-    if (server_->channelz_node_ != nullptr && channelz_socket_uuid_ != 0) {
-      server_->channelz_node_->RemoveChildSocket(channelz_socket_uuid_);
-    }
-    {
-      MutexLock lock(&server_->mu_global_);
-      if (list_position_.has_value()) {
-        server_->channels_.erase(*list_position_);
-        list_position_.reset();
-      }
-      server_->MaybeFinishShutdown();
+    MutexLock lock(&server_->mu_global_);
+    if (list_position_.has_value()) {
+      server_->channels_.erase(*list_position_);
+      list_position_.reset();
     }
+    server_->MaybeFinishShutdown();
   }
 }
 

data/src/core/server/server.h

@@ -353,10 +353,9 @@ class Server : public ServerInterface,
   // Sets up a transport.  Creates a channel stack and binds the transport to
   // the server.  Called from the listener when a new connection is accepted.
   // Takes ownership of a ref on resource_user from the caller.
-  grpc_error_handle SetupTransport(
-      Transport* transport, grpc_pollset* accepting_pollset,
-      const ChannelArgs& args,
-      const RefCountedPtr<channelz::SocketNode>& socket_node)
+  grpc_error_handle SetupTransport(Transport* transport,
+                                   grpc_pollset* accepting_pollset,
+                                   const ChannelArgs& args)
       ABSL_LOCKS_EXCLUDED(mu_global_);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
@@ -697,7 +696,6 @@ class Server : public ServerInterface,
           channel_args_.GetInt(GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT)
               .value_or(3000)))};
   const Duration max_time_in_pending_queue_;
-  absl::BitGen bitgen_ ABSL_GUARDED_BY(mu_call_);
 
   std::list<ChannelData*> channels_;
   absl::flat_hash_set<OrphanablePtr<ServerTransport>> connections_

data/src/core/telemetry/call_tracer.cc

@@ -142,9 +142,9 @@ class DelegatingClientCallTracer : public ClientCallTracer {
                                                transport_stream_stats);
       }
     }
-    void RecordEnd(const gpr_timespec& latency) override {
+    void RecordEnd() override {
       for (auto* tracer : tracers_) {
-        tracer->RecordEnd(latency);
+        tracer->RecordEnd();
       }
     }
     void RecordIncomingBytes(

data/src/core/telemetry/call_tracer.h

@@ -162,7 +162,7 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
         const grpc_transport_stream_stats* transport_stream_stats) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.
-    virtual void RecordEnd(const gpr_timespec& latency) = 0;
+    virtual void RecordEnd() = 0;
 
     // Sets an optional label on the per-attempt metrics recorded at the end of
     // the attempt.

data/src/core/{ext/transport/chttp2/transport → telemetry}/context_list_entry.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H
-#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H
+#ifndef GRPC_SRC_CORE_TELEMETRY_CONTEXT_LIST_ENTRY_H
+#define GRPC_SRC_CORE_TELEMETRY_CONTEXT_LIST_ENTRY_H
 
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
@@ -79,4 +79,4 @@ class ContextListEntry {
 typedef std::vector<ContextListEntry> ContextList;
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H
+#endif  // GRPC_SRC_CORE_TELEMETRY_CONTEXT_LIST_ENTRY_H

data/src/core/telemetry/default_tcp_tracer.cc

@@ -0,0 +1,26 @@
+// Copyright 2025 The 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/telemetry/default_tcp_tracer.h"
+
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+
+void DefaultTcpTracer::RecordConnectionMetrics(TcpConnectionMetrics metrics) {
+  MutexLock lock(&mu_);
+  connection_metrics_ = metrics;
+}
+
+}  // namespace grpc_core

data/src/core/telemetry/default_tcp_tracer.h

@@ -0,0 +1,44 @@
+// Copyright 2025 The 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_TELEMETRY_DEFAULT_TCP_TRACER_H
+#define GRPC_SRC_CORE_TELEMETRY_DEFAULT_TCP_TRACER_H
+
+#include <optional>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
+#include "src/core/telemetry/metrics.h"
+#include "src/core/telemetry/tcp_tracer.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+
+class DefaultTcpTracer final : public TcpConnectionTracer {
+ public:
+  explicit DefaultTcpTracer(
+      std::shared_ptr<GlobalStatsPluginRegistry::StatsPluginGroup>) {}
+  ~DefaultTcpTracer() override = default;
+  // Records per-connection metrics.
+  void RecordConnectionMetrics(TcpConnectionMetrics metrics) override;
+
+ private:
+  Mutex mu_;
+  TcpConnectionMetrics connection_metrics_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_TELEMETRY_DEFAULT_TCP_TRACER_H

data/src/core/telemetry/stats.h

@@ -29,14 +29,9 @@
 #include "absl/types/span.h"
 #include "src/core/telemetry/histogram_view.h"
 #include "src/core/telemetry/stats_data.h"
-#include "src/core/util/no_destruct.h"
 
 namespace grpc_core {
 
-inline GlobalStatsCollector& global_stats() {
-  return *NoDestructSingleton<GlobalStatsCollector>::Get();
-}
-
 namespace stats_detail {
 std::string StatsAsJson(absl::Span<const uint64_t> counters,
                         absl::Span<const absl::string_view> counter_name,