grpc 1.62.3 → 1.63.0

data/src/core/lib/transport/endpoint_info_handshaker.cc

@@ -0,0 +1,80 @@
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/endpoint_info_handshaker.h"
+
+#include <memory>
+
+#include "absl/status/status.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_factory.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+
+namespace grpc_core {
+
+namespace {
+
+class EndpointInfoHandshaker : public Handshaker {
+ public:
+  const char* name() const override { return "endpoint_info"; }
+
+  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                   grpc_closure* on_handshake_done,
+                   HandshakerArgs* args) override {
+    args->args = args->args
+                     .Set(GRPC_ARG_ENDPOINT_LOCAL_ADDRESS,
+                          grpc_endpoint_get_local_address(args->endpoint))
+                     .Set(GRPC_ARG_ENDPOINT_PEER_ADDRESS,
+                          grpc_endpoint_get_peer(args->endpoint));
+    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, absl::OkStatus());
+  }
+
+  void Shutdown(grpc_error_handle /*why*/) override {}
+};
+
+class EndpointInfoHandshakerFactory : public HandshakerFactory {
+ public:
+  void AddHandshakers(const ChannelArgs& /*args*/,
+                      grpc_pollset_set* /*interested_parties*/,
+                      HandshakeManager* handshake_mgr) override {
+    handshake_mgr->Add(MakeRefCounted<EndpointInfoHandshaker>());
+  }
+
+  HandshakerPriority Priority() override {
+    // Needs to be after kTCPConnectHandshakers.
+    return HandshakerPriority::kSecurityHandshakers;
+  }
+};
+
+}  // namespace
+
+void RegisterEndpointInfoHandshaker(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      HANDSHAKER_CLIENT, std::make_unique<EndpointInfoHandshakerFactory>());
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      HANDSHAKER_SERVER, std::make_unique<EndpointInfoHandshakerFactory>());
+}
+
+}  // namespace grpc_core

data/src/core/lib/transport/endpoint_info_handshaker.h

@@ -0,0 +1,37 @@
+//
+// Copyright 2022 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_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+// Set by the handshaker to indicate the local address of the endpoint.
+#define GRPC_ARG_ENDPOINT_LOCAL_ADDRESS "grpc.internal.endpoint_local_address"
+
+// Set by the handshaker to indicate the peer address of the endpoint.
+#define GRPC_ARG_ENDPOINT_PEER_ADDRESS "grpc.internal.endpoint_peer_address"
+
+namespace grpc_core {
+
+// Register the endpoint info handshaker into the configuration builder.
+void RegisterEndpointInfoHandshaker(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_ENDPOINT_INFO_HANDSHAKER_H

data/src/core/lib/transport/handshaker_factory.h

@@ -49,8 +49,7 @@ class HandshakerFactory {
     // Applicable mainly for Client handshakers.
     kTCPConnectHandshakers,
     // Handshakers responsible for the actual HTTP connect established.
-    // Applicable
-    // mainly for Client handshakers.
+    // Applicable mainly for Client handshakers.
     kHTTPConnectHandshakers,
     // Handshakers that should be called before security handshakes but after
     // connect establishment. Applicable mainly for Server handshakers

data/src/core/lib/transport/metadata.cc

@@ -22,7 +22,7 @@ namespace grpc_core {
 
 ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
                                               Arena* arena) {
-  auto hdl = arena->MakePooled<ServerMetadata>(arena);
+  auto hdl = arena->MakePooled<ServerMetadata>();
   grpc_status_code code;
   std::string message;
   grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,

data/src/core/lib/transport/metadata_batch.cc

@@ -19,7 +19,10 @@
 #include <string.h>
 
 #include <algorithm>
+#include <string>
 
+#include "absl/base/no_destructor.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
@@ -35,15 +38,73 @@ void DebugStringBuilder::Add(absl::string_view key, absl::string_view value) {
   absl::StrAppend(&out_, absl::CEscape(key), ": ", absl::CEscape(value));
 }
 
+void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
+                                           absl::string_view value) {
+  if (IsAllowListed(key)) {
+    Add(key, value);
+  } else {
+    Add(key, absl::StrCat(value.size(), " bytes redacted by allow listing."));
+  }
+}
+
+bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
+  static const absl::NoDestructor<absl::flat_hash_set<std::string>> allow_list(
+      [] {
+        absl::flat_hash_set<std::string> allow_list;
+        // go/keep-sorted start
+        allow_list.insert(std::string(ContentTypeMetadata::key()));
+        allow_list.insert(std::string(EndpointLoadMetricsBinMetadata::key()));
+        allow_list.insert(std::string(GrpcAcceptEncodingMetadata::key()));
+        allow_list.insert(std::string(GrpcEncodingMetadata::key()));
+        allow_list.insert(std::string(GrpcInternalEncodingRequest::key()));
+        allow_list.insert(std::string(GrpcLbClientStatsMetadata::key()));
+        allow_list.insert(std::string(GrpcMessageMetadata::key()));
+        allow_list.insert(std::string(GrpcPreviousRpcAttemptsMetadata::key()));
+        allow_list.insert(std::string(GrpcRetryPushbackMsMetadata::key()));
+        allow_list.insert(std::string(GrpcServerStatsBinMetadata::key()));
+        allow_list.insert(std::string(GrpcStatusMetadata::key()));
+        allow_list.insert(std::string(GrpcTagsBinMetadata::key()));
+        allow_list.insert(std::string(GrpcTimeoutMetadata::key()));
+        allow_list.insert(std::string(GrpcTraceBinMetadata::key()));
+        allow_list.insert(std::string(HostMetadata::key()));
+        allow_list.insert(std::string(HttpAuthorityMetadata::key()));
+        allow_list.insert(std::string(HttpMethodMetadata::key()));
+        allow_list.insert(std::string(HttpPathMetadata::key()));
+        allow_list.insert(std::string(HttpSchemeMetadata::key()));
+        allow_list.insert(std::string(HttpStatusMetadata::key()));
+        allow_list.insert(std::string(LbCostBinMetadata::key()));
+        allow_list.insert(std::string(LbTokenMetadata::key()));
+        allow_list.insert(std::string(TeMetadata::key()));
+        allow_list.insert(std::string(UserAgentMetadata::key()));
+        allow_list.insert(std::string(XEnvoyPeerMetadata::key()));
+
+        // go/keep-sorted end
+        // go/keep-sorted start
+        allow_list.insert(std::string(GrpcCallWasCancelled::DebugKey()));
+        allow_list.insert(std::string(GrpcRegisteredMethod::DebugKey()));
+        allow_list.insert(std::string(GrpcStatusContext::DebugKey()));
+        allow_list.insert(std::string(GrpcStatusFromWire::DebugKey()));
+        allow_list.insert(std::string(GrpcStreamNetworkState::DebugKey()));
+        allow_list.insert(std::string(GrpcTarPit::DebugKey()));
+        allow_list.insert(std::string(GrpcTrailersOnly::DebugKey()));
+        allow_list.insert(std::string(PeerString::DebugKey()));
+        allow_list.insert(std::string(WaitForReady::DebugKey()));
+        // go/keep-sorted end
+        return allow_list;
+      }());
+  return allow_list->contains(key);
+}
+
 void UnknownMap::Append(absl::string_view key, Slice value) {
-  unknown_.EmplaceBack(Slice::FromCopiedString(key), value.Ref());
+  unknown_.emplace_back(Slice::FromCopiedString(key), value.Ref());
 }
 
 void UnknownMap::Remove(absl::string_view key) {
-  unknown_.SetEnd(std::remove_if(unknown_.begin(), unknown_.end(),
-                                 [key](const std::pair<Slice, Slice>& p) {
-                                   return p.first.as_string_view() == key;
-                                 }));
+  unknown_.erase(std::remove_if(unknown_.begin(), unknown_.end(),
+                                [key](const std::pair<Slice, Slice>& p) {
+                                  return p.first.as_string_view() == key;
+                                }),
+                 unknown_.end());
 }
 
 absl::optional<absl::string_view> UnknownMap::GetStringValue(

data/src/core/lib/transport/metadata_batch.h

@@ -47,7 +47,6 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/type_list.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/custom_metadata.h"
 #include "src/core/lib/transport/metadata_compression_traits.h"
@@ -538,14 +537,17 @@ namespace metadata_detail {
 // The string is expected to be readable, but not necessarily parsable.
 class DebugStringBuilder {
  public:
-  // Add one key/value pair to the output.
-  void Add(absl::string_view key, absl::string_view value);
+  // Add one key/value pair to the output if it is allow listed.
+  // Redact only the value if it is not allow listed.
+  void AddAfterRedaction(absl::string_view key, absl::string_view value);
 
   // Finalize the output and return the string.
   // Subsequent Add calls are UB.
   std::string TakeOutput() { return std::move(out_); }
 
  private:
+  bool IsAllowListed(absl::string_view key) const;
+  void Add(absl::string_view key, absl::string_view value);
   std::string out_;
 };
 
@@ -1048,22 +1050,19 @@ class TransportSizeEncoder {
 // Handle unknown (non-trait-based) fields in the metadata map.
 class UnknownMap {
  public:
-  explicit UnknownMap(Arena* arena) : unknown_(arena) {}
-
-  using BackingType = ChunkedVector<std::pair<Slice, Slice>, 5>;
+  using BackingType = std::vector<std::pair<Slice, Slice>>;
 
   void Append(absl::string_view key, Slice value);
   void Remove(absl::string_view key);
   absl::optional<absl::string_view> GetStringValue(absl::string_view key,
                                                    std::string* backing) const;
 
-  BackingType::ConstForwardIterator begin() const { return unknown_.cbegin(); }
-  BackingType::ConstForwardIterator end() const { return unknown_.cend(); }
+  BackingType::const_iterator begin() const { return unknown_.cbegin(); }
+  BackingType::const_iterator end() const { return unknown_.cend(); }
 
   bool empty() const { return unknown_.empty(); }
   size_t size() const { return unknown_.size(); }
-  void Clear() { unknown_.Clear(); }
-  Arena* arena() const { return unknown_.arena(); }
+  void Clear() { unknown_.clear(); }
 
  private:
   // Backing store for added metadata.
@@ -1220,7 +1219,7 @@ MetadataValueAsSlice(typename Which::ValueType value) {
 template <class Derived, typename... Traits>
 class MetadataMap {
  public:
-  explicit MetadataMap(Arena* arena);
+  MetadataMap() = default;
   ~MetadataMap();
 
   // Given a compressor factory - template taking <MetadataTrait,
@@ -1281,7 +1280,7 @@ class MetadataMap {
   std::string DebugString() const {
     metadata_detail::DebugStringBuilder builder;
     Log([&builder](absl::string_view key, absl::string_view value) {
-      builder.Add(key, value);
+      builder.AddAfterRedaction(key, value);
     });
     return builder.TakeOutput();
   }
@@ -1443,9 +1442,6 @@ inline bool IsStatusOk(const MetadataMap<Derived, Args...>& m) {
          GRPC_STATUS_OK;
 }
 
-template <typename Derived, typename... Traits>
-MetadataMap<Derived, Traits...>::MetadataMap(Arena* arena) : unknown_(arena) {}
-
 template <typename Derived, typename... Traits>
 MetadataMap<Derived, Traits...>::MetadataMap(MetadataMap&& other) noexcept
     : table_(std::move(other.table_)), unknown_(std::move(other.unknown_)) {}
@@ -1479,7 +1475,7 @@ size_t MetadataMap<Derived, Traits...>::TransportSize() const {
 
 template <typename Derived, typename... Traits>
 Derived MetadataMap<Derived, Traits...>::Copy() const {
-  Derived out(unknown_.arena());
+  Derived out;
   metadata_detail::CopySink<Derived> sink(&out);
   ForEach(&sink);
   return out;

data/src/core/lib/transport/metadata_info.cc

@@ -0,0 +1,55 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/metadata_info.h"
+
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+class MetadataSizesAnnotation::MetadataSizeEncoder {
+ public:
+  explicit MetadataSizeEncoder(std::string& summary) : summary_(summary) {}
+
+  void Encode(const Slice& key, const Slice& value) {
+    AddToSummary(key.as_string_view(), value.size());
+  }
+
+  template <typename Key, typename Value>
+  void Encode(Key, const Value& value) {
+    AddToSummary(Key::key(), EncodedSizeOfKey(Key(), value));
+  }
+
+ private:
+  void AddToSummary(absl::string_view key,
+                    size_t value_length) GPR_ATTRIBUTE_NOINLINE {
+    absl::StrAppend(&summary_, key, ":",
+                    hpack_constants::SizeForEntry(key.size(), value_length),
+                    ",");
+  }
+  std::string& summary_;
+};
+
+std::string MetadataSizesAnnotation::ToString() const {
+  std::string metadata_annotation =
+      absl::StrCat("gRPC metadata soft_limit:", soft_limit_,
+                   ",hard_limit:", hard_limit_, ",");
+  MetadataSizeEncoder encoder(metadata_annotation);
+  metadata_buffer_->Encode(&encoder);
+  return metadata_annotation;
+}
+
+}  // namespace grpc_core

data/src/core/lib/transport/metadata_info.h

@@ -0,0 +1,85 @@
+// Copyright 2023 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_LIB_TRANSPORT_METADATA_INFO_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_INFO_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/lib/channel/call_tracer.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+#define DEFAULT_MAX_HEADER_LIST_SIZE (16 * 1024)
+#define DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT (8 * 1024)
+
+inline uint32_t GetSoftLimitFromChannelArgs(const ChannelArgs& args) {
+  const int soft_limit = args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
+  if (soft_limit < 0) {
+    // Set soft limit to 0.8 * hard limit if this is larger than
+    // `DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT` and
+    // `GRPC_ARG_MAX_METADATA_SIZE` is not set.
+    return std::max(
+        DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT,
+        static_cast<int>(
+            0.8 *
+            args.GetInt(GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE).value_or(-1)));
+  } else {
+    return soft_limit;
+  }
+}
+
+inline uint32_t GetHardLimitFromChannelArgs(const ChannelArgs& args) {
+  int hard_limit =
+      args.GetInt(GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE).value_or(-1);
+  if (hard_limit >= 0) {
+    return hard_limit;
+  } else {
+    // Set value to 1.25 * soft limit if this is larger than
+    // `DEFAULT_MAX_HEADER_LIST_SIZE` and
+    // `GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE` is not set.
+    const int soft_limit = args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
+    const int value = (soft_limit >= 0 && soft_limit < (INT_MAX / 1.25))
+                          ? static_cast<int>(soft_limit * 1.25)
+                          : soft_limit;
+    return std::max(value, DEFAULT_MAX_HEADER_LIST_SIZE);
+  }
+}
+
+class MetadataSizesAnnotation
+    : public CallTracerAnnotationInterface::Annotation {
+ public:
+  MetadataSizesAnnotation(grpc_metadata_batch* metadata_buffer,
+                          uint64_t soft_limit, uint64_t hard_limit)
+      : CallTracerAnnotationInterface::Annotation(
+            CallTracerAnnotationInterface::AnnotationType::kMetadataSizes),
+        metadata_buffer_(metadata_buffer),
+        soft_limit_(soft_limit),
+        hard_limit_(hard_limit) {}
+
+  std::string ToString() const override;
+
+ private:
+  class MetadataSizeEncoder;
+  grpc_metadata_batch* metadata_buffer_;
+  uint64_t soft_limit_;
+  uint64_t hard_limit_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_METADATA_INFO_H

data/src/core/lib/transport/transport_op_string.cc

@@ -27,7 +27,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/slice/slice_buffer.h"
@@ -147,10 +146,3 @@ std::string grpc_transport_op_string(grpc_transport_op* op) {
 
   return out;
 }
-
-void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
-                      grpc_call_element* elem,
-                      grpc_transport_stream_op_batch* op) {
-  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
-          grpc_transport_stream_op_batch_string(op, false).c_str());
-}

data/src/core/load_balancing/address_filtering.cc

@@ -47,7 +47,7 @@ int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
 
 namespace {
 
-class HierarchicalAddressIterator : public EndpointAddressesIterator {
+class HierarchicalAddressIterator final : public EndpointAddressesIterator {
  public:
   HierarchicalAddressIterator(
       std::shared_ptr<EndpointAddressesIterator> parent_it,

data/src/core/load_balancing/address_filtering.h

@@ -87,7 +87,7 @@ namespace grpc_core {
 
 // An address channel arg containing the hierarchical path
 // to be associated with the address.
-class HierarchicalPathArg : public RefCounted<HierarchicalPathArg> {
+class HierarchicalPathArg final : public RefCounted<HierarchicalPathArg> {
  public:
   explicit HierarchicalPathArg(std::vector<RefCountedStringValue> path)
       : path_(std::move(path)) {}

data/src/core/{client_channel/backend_metric.cc → load_balancing/backend_metric_parser.cc}

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/client_channel/backend_metric.h"
+#include "src/core/load_balancing/backend_metric_parser.h"
 
 #include <string.h>
 

data/src/core/{client_channel/backend_metric.h → load_balancing/backend_metric_parser.h}

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H
-#define GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_PARSER_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -44,4 +44,4 @@ const BackendMetricData* ParseBackendMetricData(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_BACKEND_METRIC_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_BACKEND_METRIC_PARSER_H

data/src/core/load_balancing/child_policy_handler.cc

@@ -44,7 +44,7 @@ namespace grpc_core {
 // ChildPolicyHandler::Helper
 //
 
-class ChildPolicyHandler::Helper
+class ChildPolicyHandler::Helper final
     : public LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper<
           ChildPolicyHandler> {
  public:

data/src/core/load_balancing/delegating_helper.h

@@ -58,6 +58,10 @@ class LoadBalancingPolicy::DelegatingChannelControlHelper
     parent_helper()->RequestReresolution();
   }
 
+  absl::string_view GetTarget() override {
+    return parent_helper()->GetTarget();
+  }
+
   absl::string_view GetAuthority() override {
     return parent_helper()->GetAuthority();
   }
@@ -75,6 +79,10 @@ class LoadBalancingPolicy::DelegatingChannelControlHelper
     return parent_helper()->GetEventEngine();
   }
 
+  GlobalStatsPluginRegistry::StatsPluginGroup& GetStatsPluginGroup() override {
+    return parent_helper()->GetStatsPluginGroup();
+  }
+
   void AddTraceEvent(TraceSeverity severity,
                      absl::string_view message) override {
     parent_helper()->AddTraceEvent(severity, message);

data/src/core/load_balancing/endpoint_list.cc

@@ -51,7 +51,7 @@ namespace grpc_core {
 // EndpointList::Endpoint::Helper
 //
 
-class EndpointList::Endpoint::Helper
+class EndpointList::Endpoint::Helper final
     : public LoadBalancingPolicy::DelegatingChannelControlHelper {
  public:
   explicit Helper(RefCountedPtr<Endpoint> endpoint)

data/src/core/load_balancing/grpclb/client_load_reporting_filter.h

@@ -30,7 +30,8 @@
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
-class ClientLoadReportingFilter : public ChannelFilter {
+
+class ClientLoadReportingFilter final : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -41,6 +42,7 @@ class ClientLoadReportingFilter : public ChannelFilter {
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 };
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_GRPCLB_CLIENT_LOAD_REPORTING_FILTER_H