grpc 1.84.0 → 1.85.0.pre1

data/src/core/server/server.cc

@@ -100,7 +100,7 @@ void Server::ListenerState::ConfigFetcherWatcher::UpdateConnectionManager(
   RefCountedPtr<ServerConfigFetcher::ConnectionManager>
       connection_manager_to_destroy;
   {
-    MutexLock lock(&listener_state_->mu_);
+    MutexLock lock(listener_state_->mu_);
     connection_manager_to_destroy = listener_state_->connection_manager_;
     listener_state_->connection_manager_ = std::move(connection_manager);
     listener_state_->DrainConnectionsLocked();
@@ -115,7 +115,7 @@ void Server::ListenerState::ConfigFetcherWatcher::UpdateConnectionManager(
 }
 
 void Server::ListenerState::ConfigFetcherWatcher::StopServing() {
-  MutexLock lock(&listener_state_->mu_);
+  MutexLock lock(listener_state_->mu_);
   listener_state_->is_serving_ = false;
   listener_state_->DrainConnectionsLocked();
 }
@@ -151,7 +151,7 @@ void Server::ListenerState::Start() {
         std::move(watcher));
   } else {
     {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       started_ = true;
       is_serving_ = true;
     }
@@ -163,7 +163,7 @@ void Server::ListenerState::Stop() {
   absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
       connections;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // Orphan the connections so that they can start cleaning up.
     connections = std::move(connections_);
     connections_.clear();
@@ -184,7 +184,7 @@ std::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
     const ChannelArgs& args, grpc_endpoint* endpoint) {
   RefCountedPtr<ServerConfigFetcher::ConnectionManager> connection_manager;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!is_serving_) {
       // Not serving
       return std::nullopt;
@@ -224,7 +224,7 @@ std::optional<ChannelArgs> Server::ListenerState::AddLogicalConnection(
     }
     new_args = (*args_result).SetObject(security_connector);
   }
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // Since we let go of the lock earlier, we need to protect ourselves against
   // time-of-check-to-time-of-use cases. The server may have stopped serving
   // or the connection manager may have changed before we add the connection
@@ -247,7 +247,7 @@ void Server::ListenerState::OnHandshakeDone(
   OrphanablePtr<ListenerInterface::LogicalConnection> connection_to_remove;
   {
     // Remove the connection if it wasn't already removed.
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto connection_handle = connections_.extract(connection);
     if (!connection_handle.empty()) {
       connection_to_remove = std::move(connection_handle.value());
@@ -261,7 +261,7 @@ void Server::ListenerState::RemoveLogicalConnection(
     ListenerInterface::LogicalConnection* connection) {
   OrphanablePtr<ListenerInterface::LogicalConnection> connection_to_remove;
   // Remove the connection if it wasn't already removed.
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto connection_handle = connections_.extract(connection);
   if (!connection_handle.empty()) {
     connection_to_remove = std::move(connection_handle.value());
@@ -306,7 +306,7 @@ void Server::ListenerState::OnDrainGraceTimer() {
   absl::flat_hash_set<OrphanablePtr<ListenerInterface::LogicalConnection>>
       connections_to_be_drained;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (connections_to_be_drained_list_.empty()) {
       return;
     }
@@ -605,7 +605,7 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       while (true) {
         NextPendingCall pending_call;
         {
-          MutexLock lock(&server_->mu_call_);
+          MutexLock lock(server_->mu_call_);
           while (!pending_filter_stack_.empty() &&
                  pending_filter_stack_.front().Age() >
                      server_->max_time_in_pending_queue_) {
@@ -675,7 +675,7 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
     size_t cq_idx = 0;
     size_t loop_count;
     {
-      MutexLock lock(&server_->mu_call_);
+      MutexLock lock(server_->mu_call_);
       for (loop_count = 0; loop_count < requests_per_cq_.size(); loop_count++) {
         cq_idx =
             (start_request_queue_index + loop_count) % requests_per_cq_.size();
@@ -720,7 +720,7 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
     size_t loop_count;
     {
       std::vector<std::shared_ptr<ActivityWaiter>> removed_pending;
-      MutexLock lock(&server_->mu_call_);
+      MutexLock lock(server_->mu_call_);
       while (!pending_promises_.empty() &&
              pending_promises_.front()->Age() >
                  server_->max_time_in_pending_queue_) {
@@ -1027,7 +1027,7 @@ class Server::TransportConnectivityWatcher
     // Don't do anything until we are being shut down.
     if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
     // Shut down channel.
-    MutexLock lock(&server_->mu_global_);
+    MutexLock lock(server_->mu_global_);
     server_->connections_.erase(transport_.get());
     --server_->connections_open_;
     server_->stream_quota_->DecrementOpenChannels();
@@ -1214,7 +1214,7 @@ Server::~Server() {
 }
 
 void Server::AddData(channelz::DataSink sink) {
-  MutexLock global_lock(&mu_global_);
+  MutexLock global_lock(mu_global_);
   sink.AddData(
       "server",
       channelz::PropertyList()
@@ -1279,7 +1279,7 @@ void Server::Start() {
     }
   }
   {
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     starting_ = true;
   }
   // Register the interested parties from the config fetcher to the cq pollsets
@@ -1295,7 +1295,7 @@ void Server::Start() {
   for (auto& listener_state : listener_states_) {
     listener_state->Start();
   }
-  MutexLock lock(&mu_global_);
+  MutexLock lock(mu_global_);
   starting_ = false;
   starting_cv_.Signal();
 }
@@ -1325,7 +1325,7 @@ grpc_error_handle Server::SetupTransport(
         channel_stack_type);
     if (!destination.ok()) return destination.status();
     t->SetCallDestination(std::move(*destination));
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     if (ShutdownCalled()) {
       t->DisconnectWithError(GRPC_ERROR_CREATE("Server shutdown"));
     }
@@ -1384,7 +1384,7 @@ grpc_error_handle Server::SetupTransport(
 }
 
 bool Server::HasOpenConnections() {
-  MutexLock lock(&mu_global_);
+  MutexLock lock(mu_global_);
   return !channels_.empty() || !connections_.empty();
 }
 
@@ -1461,7 +1461,7 @@ void Server::MaybeFinishShutdown() {
     return;
   }
   {
-    MutexLock lock(&mu_call_);
+    MutexLock lock(mu_call_);
     KillPendingWorkLocked(GRPC_ERROR_CREATE("Server Shutdown"));
   }
   if (!channels_.empty() || connections_open_ > 0 ||
@@ -1508,7 +1508,7 @@ std::vector<RefCountedPtr<Channel>> Server::GetChannelsLocked() const {
 
 void Server::ListenerDestroyDone(void* arg, grpc_error_handle /*error*/) {
   Server* server = static_cast<Server*>(arg);
-  MutexLock lock(&server->mu_global_);
+  MutexLock lock(server->mu_global_);
   server->listeners_destroyed_++;
   server->MaybeFinishShutdown();
 }
@@ -1540,7 +1540,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   absl::flat_hash_set<OrphanablePtr<ServerTransport>> removing_connections;
   {
     // Wait for startup to be finished.  Locks mu_global.
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     while (starting_) {
       starting_cv_.Wait(&mu_global_);
     }
@@ -1560,7 +1560,7 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     removing_connections.swap(connections_);
     // Collect all unregistered then registered calls.
     {
-      MutexLock lock(&mu_call_);
+      MutexLock lock(mu_call_);
       KillPendingWorkLocked(GRPC_ERROR_CREATE("Server Shutdown"));
     }
     ShutdownUnrefOnShutdownCall();
@@ -1584,7 +1584,7 @@ void Server::StopListening() {
 void Server::CancelAllCalls() {
   ChannelBroadcaster broadcaster;
   {
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     broadcaster.FillChannelsLocked(GetChannelsLocked());
   }
   broadcaster.BroadcastShutdown(
@@ -1594,7 +1594,7 @@ void Server::CancelAllCalls() {
 void Server::SendGoaways() {
   ChannelBroadcaster broadcaster;
   {
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     broadcaster.FillChannelsLocked(GetChannelsLocked());
   }
   broadcaster.BroadcastShutdown(/*send_goaway=*/true, absl::OkStatus());
@@ -1602,7 +1602,7 @@ void Server::SendGoaways() {
 
 void Server::Orphan() {
   {
-    MutexLock lock(&mu_global_);
+    MutexLock lock(mu_global_);
     GRPC_CHECK(ShutdownCalled() || listener_states_.empty());
     GRPC_CHECK(listeners_destroyed_ == listener_states_.size());
   }
@@ -1714,7 +1714,7 @@ class Server::ChannelData::ConnectivityWatcher
     if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
     chand_->server_->stream_quota_->DecrementOpenChannels();
     // Shut down channel.
-    MutexLock lock(&chand_->server_->mu_global_);
+    MutexLock lock(chand_->server_->mu_global_);
     chand_->Destroy();
   }
 
@@ -1729,7 +1729,7 @@ class Server::ChannelData::ConnectivityWatcher
 Server::ChannelData::~ChannelData() {
   if (server_ != nullptr) {
     server_->stream_quota_->DecrementOpenChannels();
-    MutexLock lock(&server_->mu_global_);
+    MutexLock lock(server_->mu_global_);
     if (list_position_.has_value()) {
       server_->channels_.erase(*list_position_);
       list_position_.reset();
@@ -1748,7 +1748,7 @@ void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
   channelz_socket_uuid_ = channelz_socket_uuid;
   // Publish channel.
   {
-    MutexLock lock(&server_->mu_global_);
+    MutexLock lock(server_->mu_global_);
     server_->channels_.push_front(this);
     list_position_ = server_->channels_.begin();
   }
@@ -1898,7 +1898,7 @@ Server::CallData::CallData(grpc_call_element* elem,
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
                     elem, grpc_schedule_on_exec_ctx);
 
-  // TODO(snohria): Add the same for Call-V3 as well.
+  // TODO(snohria) : [PH2][P1] : Add the same for Call-V3 as well.
   server_->stream_quota_->IncrementOutstandingRequests();
 }
 
@@ -1908,7 +1908,7 @@ Server::CallData::~CallData() {
   grpc_byte_buffer_destroy(payload_);
 
   if (server_ != nullptr) {
-    // TODO(snohria): Add the same for Call-V3 as well.
+    // TODO(snohria) : [PH2][P1] : Add the same for Call-V3 as well.
     server_->stream_quota_->DecrementOutstandingRequests();
   }
 }

data/src/core/server/server.h

@@ -616,7 +616,8 @@ class Server : public ServerInterface,
       size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag,
       grpc_byte_buffer** optional_payload, RegisteredMethod* rm);
 
-  std::vector<RefCountedPtr<Channel>> GetChannelsLocked() const;
+  std::vector<RefCountedPtr<Channel>> GetChannelsLocked() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_global_);
 
   // Take a shutdown ref for a request (increment by 2) and return if shutdown
   // has not been called.
@@ -630,7 +631,7 @@ class Server : public ServerInterface,
   // appropriate.
   void ShutdownUnrefOnRequest() ABSL_LOCKS_EXCLUDED(mu_global_) {
     if (shutdown_refs_.fetch_sub(2, std::memory_order_acq_rel) == 2) {
-      MutexLock lock(&mu_global_);
+      MutexLock lock(mu_global_);
       MaybeFinishShutdown();
     }
   }
@@ -717,7 +718,7 @@ class Server : public ServerInterface,
               .value_or(3000)))};
   const Duration max_time_in_pending_queue_;
 
-  std::list<ChannelData*> channels_;
+  std::list<ChannelData*> channels_ ABSL_GUARDED_BY(mu_global_);
   absl::flat_hash_set<OrphanablePtr<ServerTransport>> connections_
       ABSL_GUARDED_BY(mu_global_);
   RefCountedPtr<ServerConfigFetcher::ConnectionManager> connection_manager_

data/src/core/server/server_config_selector_filter.cc

@@ -81,7 +81,7 @@ class LegacyServerConfigSelectorFilter final
   };
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return config_selector_.value();
   }
 
@@ -94,7 +94,7 @@ class LegacyServerConfigSelectorFilter final
         : filter_(filter) {}
     void OnServerConfigSelectorUpdate(
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
-      MutexLock lock(&filter_->mu_);
+      MutexLock lock(filter_->mu_);
       filter_->config_selector_ = std::move(update);
     }
 
@@ -128,7 +128,7 @@ LegacyServerConfigSelectorFilter::LegacyServerConfigSelectorFilter(
   GRPC_CHECK(server_config_selector_provider_ != nullptr);
   watcher_ = std::make_shared<ServerConfigSelectorWatcher>(Ref());
   auto config_selector = server_config_selector_provider_->Watch(watcher_);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // It's possible for the watcher to have already updated config_selector_
   if (!config_selector_.has_value()) {
     config_selector_ = std::move(config_selector);

data/src/core/server/xds_server_config_fetcher_legacy.cc

@@ -174,7 +174,7 @@ class XdsServerConfigFetcher::ListenerWatcher final
   // filter_chain_match_manager_ in use.
   void PendingFilterChainMatchManagerReady(
       FilterChainMatchManager* filter_chain_match_manager) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     PendingFilterChainMatchManagerReadyLocked(filter_chain_match_manager);
   }
   void PendingFilterChainMatchManagerReadyLocked(
@@ -534,13 +534,13 @@ void XdsServerConfigFetcher::StartWatch(
   XdsListenerResourceType::StartWatch(xds_client_.get(),
                                       listener_watcher_ptr->ResourceName(),
                                       std::move(listener_watcher));
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   listener_watchers_.emplace(watcher_ptr, listener_watcher_ptr);
 }
 
 void XdsServerConfigFetcher::CancelWatch(
     ServerConfigFetcher::WatcherInterface* watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = listener_watchers_.find(watcher);
   if (it != listener_watchers_.end()) {
     // Cancel the watch on the listener before erasing
@@ -570,7 +570,7 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     absl::StatusOr<std::shared_ptr<const XdsListenerResource>> listener,
     RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
   if (!listener.ok()) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     OnFatalError(AddMessagePrefix(absl::StrCat("LDS resource ", ResourceName()),
                                   listener.status()));
     return;
@@ -581,13 +581,13 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
   auto* tcp_listener =
       std::get_if<XdsListenerResource::TcpListener>(&(*listener)->listener);
   if (tcp_listener == nullptr) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     OnFatalError(absl::FailedPreconditionError(absl::StrCat(
         "LDS resource ", ResourceName(), " is not a TCP listener")));
     return;
   }
   if (tcp_listener->address != listening_address_) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     OnFatalError(absl::FailedPreconditionError(
         absl::StrCat("LDS resource ", ResourceName(),
                      " address does not match listening address")));
@@ -596,7 +596,7 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
   auto new_filter_chain_match_manager = MakeRefCounted<FilterChainMatchManager>(
       xds_client_.Ref(DEBUG_LOCATION, "FilterChainMatchManager"),
       tcp_listener->filter_chain_map, tcp_listener->default_filter_chain);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (filter_chain_match_manager_ == nullptr ||
       !(new_filter_chain_match_manager->filter_chain_map() ==
             filter_chain_match_manager_->filter_chain_map() &&
@@ -744,7 +744,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   std::vector<WatcherToStart> watchers_to_start;
   watchers_to_start.reserve(resource_names.size());
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     for (const auto& resource_name : resource_names) {
       ++rds_resources_yet_to_fetch_;
       auto route_config_watcher = MakeRefCounted<RouteConfigWatcher>(
@@ -773,7 +773,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     Orphaned() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // Cancel the RDS watches to clear up the weak refs
   for (const auto& entry : rds_map_) {
     XdsRouteConfigResourceType::CancelWatch(xds_client_.get(), entry.first,
@@ -788,7 +788,7 @@ absl::StatusOr<RefCountedPtr<XdsCertificateProvider>>
 XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     CreateOrGetXdsCertificateProviderFromFilterChainData(
         const XdsListenerResource::FilterChainData* filter_chain) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = certificate_providers_map_.find(filter_chain);
   if (it != certificate_providers_map_.end()) return it->second;
   // Configure root cert.
@@ -842,7 +842,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
             route_config) {
   RefCountedPtr<ListenerWatcher> listener_watcher;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto& state = rds_map_[resource_name];
     if (!state.rds_update.has_value()) {
       if (--rds_resources_yet_to_fetch_ == 0) {
@@ -1074,7 +1074,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
         absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
             initial_resource;
         {
-          MutexLock lock(&mu_);
+          MutexLock lock(mu_);
           initial_resource = rds_map_[rds_name].rds_update.value();
         }
         server_config_selector_provider =
@@ -1248,7 +1248,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         std::shared_ptr<ServerConfigSelectorWatcher> watcher) {
   absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>> resource;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     GRPC_CHECK(watcher_ == nullptr);
     watcher_ = std::move(watcher);
     resource = resource_;
@@ -1265,7 +1265,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::CancelWatch(
         std::shared_ptr<ServerConfigSelectorWatcher> watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_CHECK(watcher == watcher_);
   watcher_.reset();
 }
@@ -1274,7 +1274,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     DynamicXdsServerConfigSelectorProvider::OnRouteConfigChanged(
         absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
             rds_update) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (!rds_update.ok()) {
     rds_update = absl::UnavailableError(absl::StrCat(
         "RDS resource ", resource_name_, ": ", rds_update.status().message()));

data/src/core/telemetry/default_tcp_tracer.cc

@@ -19,7 +19,7 @@
 namespace grpc_core {
 
 void DefaultTcpTracer::RecordConnectionMetrics(TcpConnectionMetrics metrics) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   connection_metrics_ = metrics;
 }
 

data/src/core/telemetry/instrument.cc

@@ -179,7 +179,7 @@ CollectionScope::CollectionScope(
     if (parent != nullptr) {
       labels_of_interest_.Merge(parent->labels_of_interest_);
       auto& shard = parent->child_shard(this);
-      MutexLock lock(&shard.mu);
+      MutexLock lock(shard.mu);
       shard.children.insert(this);
     }
   }
@@ -189,7 +189,7 @@ CollectionScope::~CollectionScope() {
   for (const auto& parent : parents_) {
     if (parent != nullptr) {
       auto& shard = parent->child_shard(this);
-      MutexLock lock(&shard.mu);
+      MutexLock lock(shard.mu);
       shard.children.erase(this);
     }
   }
@@ -197,7 +197,7 @@ CollectionScope::~CollectionScope() {
     // TODO(ctiller): Consider a different entry point than GetDomainStorage
     // for this post-aggregation. We ought to be able to do this step without
     // accessing full_labels.
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     for (auto& storage_pair : shard.storage) {
       for (const auto& parent : parents_) {
         if (parent != nullptr) {
@@ -213,7 +213,7 @@ CollectionScope::~CollectionScope() {
 size_t CollectionScope::TestOnlyCountStorageHeld() const {
   size_t count = 0;
   for (const auto& shard : storage_shards_) {
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     count += shard.storage.size();
   }
   return count;
@@ -229,7 +229,7 @@ void CollectionScope::ForEachUniqueStorage(
     absl::FunctionRef<void(instrument_detail::DomainStorage*)> cb,
     absl::flat_hash_set<instrument_detail::DomainStorage*>& visited) {
   for (auto& shard : storage_shards_) {
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     for (const auto& s : shard.storage) {
       if (visited.insert(s.second.get()).second) {
         cb(s.second.get());
@@ -237,7 +237,7 @@ void CollectionScope::ForEachUniqueStorage(
     }
   }
   for (auto& shard : child_shards_) {
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     for (auto* child : shard.children) {
       child->ForEachUniqueStorage(cb, visited);
     }
@@ -246,11 +246,11 @@ void CollectionScope::ForEachUniqueStorage(
 
 void CollectionScope::TestOnlyReset() {
   for (auto& shard : storage_shards_) {
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     shard.storage.clear();
   }
   for (auto& shard : child_shards_) {
-    MutexLock lock(&shard.mu);
+    MutexLock lock(shard.mu);
     shard.children.clear();
   }
 }
@@ -341,12 +341,26 @@ void MetricsQuery::Run(RefCountedPtr<CollectionScope> scope,
     const auto& storages = pair.second.storage;
     GRPC_CHECK(!metrics.empty());
     if (storages.empty()) continue;
+    const InstrumentLabelList domain_labels = domain->label_names();
+    InstrumentLabelList label_keys;
+    for (size_t i = 0; i < domain_labels.size(); ++i) {
+      if (scope->ObservesLabel(domain_labels[i])) {
+        label_keys.Append(domain_labels[i]);
+      }
+    }
     this->Apply(
-        domain->label_names(),
+        label_keys,
         [&](MetricsSink& sink) {
+          std::vector<std::string> label_values;
+          label_values.reserve(label_keys.size());
           for (auto& storage : storages) {
-            const auto label_values = storage->label();
-            const auto label_keys = domain->label_names();
+            label_values.clear();
+            const auto storage_labels = storage->label();
+            for (size_t i = 0; i < domain_labels.size(); ++i) {
+              if (scope->ObservesLabel(domain_labels[i])) {
+                label_values.emplace_back(storage_labels[i]);
+              }
+            }
             instrument_detail::GaugeStorage gauge_storage(storage->domain());
             storage->FillGaugeStorage(gauge_storage);
             for (const auto* metric : metrics) {
@@ -859,7 +873,7 @@ void QueryableDomain::ForEachInstrument(
 size_t QueryableDomain::TestOnlyCountStorageHeld() const {
   size_t count = 0;
   for (size_t i = 0; i < map_shards_size_; ++i) {
-    MutexLock lock(&map_shards_[i].mu);
+    MutexLock lock(map_shards_[i].mu);
     map_shards_[i].storage_map.ForEach(
         [&count](const auto&, const auto&) { count++; });
   }
@@ -981,7 +995,7 @@ RefCountedPtr<DomainStorage> QueryableDomain::GetDomainStorage(
   }
   size_t shard_idx = absl::HashOf(key_labels) % scope->storage_shards_.size();
   auto& shard = scope->storage_shards_[shard_idx];
-  MutexLock lock(&shard.mu);
+  MutexLock lock(shard.mu);
   auto it = shard.storage.find({this, key_labels});
   if (it != shard.storage.end()) {
     return it->second;
@@ -1044,7 +1058,7 @@ class GlobalCollectionScopeManager {
   RefCountedPtr<CollectionScope> CreateRootScope(InstrumentLabelSet labels,
                                                  size_t child_shards_count,
                                                  size_t storage_shards_count) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (auto* building = std::get_if<Building>(&state_); building != nullptr) {
       auto scope = CreateCollectionScope({}, labels, child_shards_count,
                                          storage_shards_count);
@@ -1085,7 +1099,7 @@ class GlobalCollectionScopeManager {
   }
 
   RefCountedPtr<CollectionScope> GetGlobalScope() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (auto* building = std::get_if<Building>(&state_); building != nullptr) {
       auto global_scope = CreateCollectionScope(building->root_scopes,
                                                 InstrumentLabelSet(), 32, 32);
@@ -1098,7 +1112,7 @@ class GlobalCollectionScopeManager {
 
   void TestOnlyReset() {
     std::variant<Building, Published> state;
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     state = std::exchange(state_, Building{});
     if (auto* published = std::get_if<Published>(&state);
         published != nullptr) {

data/src/core/telemetry/instrument.h

@@ -1043,7 +1043,7 @@ class InstrumentDomainImpl final : public QueryableDomain {
     uint64_t SumCounter(size_t offset) override { return backend_.Sum(offset); }
     void FillGaugeStorage(GaugeStorage& storage) override {
       GaugeSink sink(storage);
-      MutexLock lock(&gauge_providers_mu_);
+      MutexLock lock(gauge_providers_mu_);
       for (auto* provider : gauge_providers_) {
         provider->PopulateGaugeData(sink);
       }
@@ -1059,12 +1059,12 @@ class InstrumentDomainImpl final : public QueryableDomain {
           backend_(instrument_domain->allocated_counter_slots()) {}
 
     void RegisterGaugeProvider(GaugeProvider* provider) {
-      MutexLock lock(&gauge_providers_mu_);
+      MutexLock lock(gauge_providers_mu_);
       gauge_providers_.push_back(provider);
     }
 
     void UnregisterGaugeProvider(GaugeProvider* provider) {
-      MutexLock lock(&gauge_providers_mu_);
+      MutexLock lock(gauge_providers_mu_);
       gauge_providers_.erase(std::remove(gauge_providers_.begin(),
                                          gauge_providers_.end(), provider),
                              gauge_providers_.end());

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -154,7 +154,7 @@ static void maybe_complete_tsi_next(
     recv_message_result* pending_recv_message_result) {
   recv_message_result* r;
   {
-    grpc_core::MutexLock lock(&client->mu);
+    grpc_core::MutexLock lock(client->mu);
     client->receive_status_finished |= receive_status_finished;
     if (pending_recv_message_result != nullptr) {
       GRPC_CHECK_EQ(client->pending_recv_message_result, nullptr);
@@ -374,7 +374,7 @@ class HandshakeQueue {
 
   void RequestHandshake(alts_grpc_handshaker_client* client) {
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       if (outstanding_handshakes_ == max_outstanding_handshakes_) {
         // Max number already running, add to queue.
         queued_handshakes_.push_back(client);
@@ -389,7 +389,7 @@ class HandshakeQueue {
   void HandshakeDone() {
     alts_grpc_handshaker_client* client = nullptr;
     {
-      grpc_core::MutexLock lock(&mu_);
+      grpc_core::MutexLock lock(mu_);
       if (queued_handshakes_.empty()) {
         // Nothing more in queue.  Decrement count and return immediately.
         --outstanding_handshakes_;

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -488,7 +488,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       return TSI_FAILED_PRECONDITION;
     }
     {
-      grpc_core::MutexLock lock(&handshaker->mu);
+      grpc_core::MutexLock lock(handshaker->mu);
       GRPC_CHECK_EQ(handshaker->client, nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
@@ -592,7 +592,7 @@ static tsi_result handshaker_next(
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
   {
-    grpc_core::MutexLock lock(&handshaker->mu);
+    grpc_core::MutexLock lock(handshaker->mu);
     if (handshaker->shutdown) {
       LOG(INFO) << "TSI handshake shutdown";
       if (error != nullptr) *error = "handshake shutdown";
@@ -656,7 +656,7 @@ static void handshaker_shutdown(tsi_handshaker* self, bool /*peer_closed*/) {
   GRPC_CHECK_NE(self, nullptr);
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
-  grpc_core::MutexLock lock(&handshaker->mu);
+  grpc_core::MutexLock lock(handshaker->mu);
   if (handshaker->shutdown) {
     return;
   }
@@ -700,7 +700,7 @@ static const tsi_handshaker_vtable handshaker_vtable_dedicated = {
 
 bool alts_tsi_handshaker_has_shutdown(alts_tsi_handshaker* handshaker) {
   GRPC_CHECK_NE(handshaker, nullptr);
-  grpc_core::MutexLock lock(&handshaker->mu);
+  grpc_core::MutexLock lock(handshaker->mu);
   return handshaker->shutdown;
 }