grpc 1.72.0 → 1.74.0.pre2

data/src/core/server/xds_server_config_fetcher.cc

@@ -70,6 +70,7 @@
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -210,6 +211,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
       const ChannelArgs& args, grpc_endpoint* tcp) override;
 
+  void UpdateBlackboard(const Blackboard* old_blackboard,
+                        Blackboard* new_blackboard) override;
+
   // Invoked by ListenerWatcher to start fetching referenced RDS resources.
   void StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ListenerWatcher::mu_);
@@ -248,6 +252,10 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
           route_config);
   void OnAmbientError(const std::string& resource_name, absl::Status status);
 
+  // Executes cb once for each unique filter chain object in the LDS resource.
+  void ForEachFilterChain(
+      absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb);
+
   RefCountedPtr<GrpcXdsClient> xds_client_;
   // This ref is only kept around till the FilterChainMatchManager becomes
   // ready.
@@ -402,7 +410,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       return static_resource_.status();
     }
     return XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         static_resource_.value(), http_filters_);
   }
@@ -529,7 +537,7 @@ void XdsServerConfigFetcher::StartWatch(
   XdsListenerResourceType::StartWatch(
       xds_client_.get(),
       ListenerResourceName(
-          static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
               .server_listener_resource_name_template(),
           listening_address),
       std::move(listener_watcher));
@@ -546,7 +554,7 @@ void XdsServerConfigFetcher::CancelWatch(
     XdsListenerResourceType::CancelWatch(
         xds_client_.get(),
         ListenerResourceName(
-            static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+            DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
                 .server_listener_resource_name_template(),
             it->second->listening_address()),
         it->second, false /* delay_unsubscription */);
@@ -685,37 +693,47 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       default_filter_chain_(std::move(default_filter_chain)) {}
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
-  // Get the set of RDS resources to watch on. Also get the set of
-  // FilterChainData so that we can reverse the list of HTTP filters since
-  // received data moves *up* the stack in Core.
-  std::set<std::string> resource_names;
+    ForEachFilterChain(
+        absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb) {
+  // A given FilterChainData object may appear more than once in the map,
+  // but we want to invoke the callback exactly once for each
+  // FilterChainData object.  Therefore, we start by constructing a set
+  // of all FilterChainData objects by address, to weed out duplicates.
   std::set<XdsListenerResource::FilterChainData*> filter_chain_data_set;
   for (const auto& destination_ip : filter_chain_map_.destination_ip_vector) {
     for (const auto& source_type : destination_ip.source_types_array) {
       for (const auto& source_ip : source_type) {
         for (const auto& source_port_pair : source_ip.ports_map) {
           auto* filter_chain_data = source_port_pair.second.data.get();
-          const auto* rds_name = std::get_if<std::string>(
-              &filter_chain_data->http_connection_manager.route_config);
-          if (rds_name != nullptr) resource_names.insert(*rds_name);
           filter_chain_data_set.insert(filter_chain_data);
         }
       }
     }
   }
-  if (default_filter_chain_.has_value()) {
-    auto& hcm = default_filter_chain_->http_connection_manager;
-    const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
-    if (rds_name != nullptr) resource_names.insert(*rds_name);
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
-  }
-  // Reverse the lists of HTTP filters in all the filter chains
+  // Invoke the callback once for each FilterChainData object.
   for (auto* filter_chain_data : filter_chain_data_set) {
-    auto& hcm = filter_chain_data->http_connection_manager;
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+    cb(*filter_chain_data);
   }
-  // Start watching on referenced RDS resources
+  // Also invoke the callback for the default filter chain, if present.
+  if (default_filter_chain_.has_value()) {
+    cb(*default_filter_chain_);
+  }
+}
+
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
+  // Get the set of RDS resources to watch on. Also reverse the list of
+  // HTTP filters in each filter chain, since received data moves *up*
+  // the stack on the server side.
+  std::set<std::string> resource_names;
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
+        if (rds_name != nullptr) resource_names.insert(*rds_name);
+        std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+      });
+  // Start watching referenced RDS resources.
   struct WatcherToStart {
     std::string resource_name;
     RefCountedPtr<RouteConfigWatcher> watcher;
@@ -1026,7 +1044,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   // flows *up* the stack.
   std::vector<const grpc_channel_filter*> filters;
   const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry();
   for (const auto& http_filter :
        filter_chain->http_connection_manager.http_filters) {
@@ -1090,6 +1108,26 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   return args;
 }
 
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    UpdateBlackboard(const Blackboard* old_blackboard,
+                     Blackboard* new_blackboard) {
+  const auto& http_filter_registry =
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          .http_filter_registry();
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        for (const auto& http_filter : hcm.http_filters) {
+          const XdsHttpFilterImpl* filter_impl =
+              http_filter_registry.GetFilterForType(
+                  http_filter.config.config_proto_type_name);
+          CHECK_NE(filter_impl, nullptr);  // Enforced in config validation.
+          filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
+                                        new_blackboard);
+        }
+      });
+}
+
 //
 // XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::XdsServerConfigSelector
 //
@@ -1237,7 +1275,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     return resource.status();
   }
   return XdsServerConfigSelector::Create(
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry(),
       resource.value(), http_filters_);
 }
@@ -1269,7 +1307,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     watcher_->OnServerConfigSelectorUpdate(resource_.status());
   } else {
     watcher_->OnServerConfigSelectorUpdate(XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         *resource_, http_filters_));
   }
@@ -1304,7 +1342,7 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     LOG(ERROR) << "Failed to create xds client: " << xds_client.status();
     return nullptr;
   }
-  if (static_cast<const grpc_core::GrpcXdsBootstrap&>(
+  if (grpc_core::DownCast<const grpc_core::GrpcXdsBootstrap&>(
           (*xds_client)->bootstrap())
           .server_listener_resource_name_template()
           .empty()) {

data/src/core/service_config/service_config.h

@@ -72,7 +72,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   virtual ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) = 0;
+      size_t index) const = 0;
 
   /// Retrieves the vector of parsed configs for the method identified
   /// by \a path.  The lifetime of the returned vector and contained objects

data/src/core/service_config/service_config_impl.h

@@ -86,7 +86,7 @@ class ServiceConfigImpl final : public ServiceConfig {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) override {
+      size_t index) const override {
     DCHECK(index < parsed_global_configs_.size());
     return parsed_global_configs_[index].get();
   }

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/telemetry/context_list_entry.cc

@@ -0,0 +1,38 @@
+// 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 "src/core/telemetry/context_list_entry.h"
+
+namespace grpc_core {
+
+namespace {
+CopyContextFn g_get_copied_context_fn = nullptr;
+DeleteContextFn g_delete_copied_context_fn = nullptr;
+}  // namespace
+
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn) {
+  g_get_copied_context_fn = fn;
+}
+
+void GrpcHttp2SetDeleteContextFn(DeleteContextFn fn) {
+  g_delete_copied_context_fn = fn;
+}
+
+CopyContextFn GrpcHttp2GetCopyContextFn() { return g_get_copied_context_fn; }
+
+DeleteContextFn GrpcHttp2GetDeleteContextFn() {
+  return g_delete_copied_context_fn;
+}
+
+}  // namespace grpc_core

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

@@ -16,21 +16,28 @@
 //
 //
 
-#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>
 #include <stdint.h>
 
-#include <memory>
-#include <utility>
 #include <vector>
 
-#include "src/core/telemetry/tcp_tracer.h"
-
 namespace grpc_core {
 
+class Arena;
+
+using CopyContextFn = void* (*)(Arena*);
+using DeleteContextFn = void (*)(void*);
+
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn);
+void GrpcHttp2SetDeleteContextFn(DeleteContextFn fn);
+
+CopyContextFn GrpcHttp2GetCopyContextFn();
+DeleteContextFn GrpcHttp2GetDeleteContextFn();
+
 /// An RPC trace context and associated information. Each RPC/stream is
 /// associated with a unique \a context. A new ContextList entry is created when
 /// a chunk of data stored in an outgoing buffer is going to be
@@ -41,25 +48,48 @@ class ContextListEntry {
  public:
   ContextListEntry(void* context, int64_t outbuf_offset,
                    int64_t num_traced_bytes, size_t byte_offset,
-                   size_t stream_index,
-                   std::shared_ptr<TcpCallTracer> tcp_tracer)
+                   size_t stream_index)
       : trace_context_(context),
         outbuf_offset_(outbuf_offset),
         num_traced_bytes_in_chunk_(num_traced_bytes),
         byte_offset_in_stream_(byte_offset),
-        stream_index_(stream_index),
-        tcp_tracer_(std::move(tcp_tracer)) {}
+        stream_index_(stream_index) {}
 
   ContextListEntry() = delete;
+  ContextListEntry(const ContextListEntry&) = delete;
+  ContextListEntry& operator=(const ContextListEntry&) = delete;
+
+  ContextListEntry(ContextListEntry&& other) noexcept
+      : trace_context_(other.trace_context_),
+        outbuf_offset_(other.outbuf_offset_),
+        num_traced_bytes_in_chunk_(other.num_traced_bytes_in_chunk_),
+        byte_offset_in_stream_(other.byte_offset_in_stream_),
+        stream_index_(other.stream_index_) {
+    other.trace_context_ = nullptr;
+  }
+  ContextListEntry& operator=(ContextListEntry&& other) noexcept {
+    if (this != &other) {
+      trace_context_ = other.trace_context_;
+      other.trace_context_ = nullptr;
+      outbuf_offset_ = other.outbuf_offset_;
+      num_traced_bytes_in_chunk_ = other.num_traced_bytes_in_chunk_;
+      byte_offset_in_stream_ = other.byte_offset_in_stream_;
+      stream_index_ = other.stream_index_;
+    }
+    return *this;
+  }
+
+  ~ContextListEntry() {
+    if (trace_context_ != nullptr) {
+      GrpcHttp2GetDeleteContextFn()(trace_context_);
+    }
+  }
 
   void* TraceContext() { return trace_context_; }
   int64_t OutbufOffset() { return outbuf_offset_; }
   int64_t NumTracedBytesInChunk() { return num_traced_bytes_in_chunk_; }
   size_t ByteOffsetInStream() { return byte_offset_in_stream_; }
   size_t StreamIndex() { return stream_index_; }
-  std::shared_ptr<TcpCallTracer> ReleaseTcpTracer() {
-    return std::move(tcp_tracer_);
-  }
 
  private:
   void* trace_context_;
@@ -72,11 +102,11 @@ class ContextListEntry {
   // Index of the current chunk in the RPC stream.
   // Set to zero for the first chunk of the RPC stream.
   size_t stream_index_;
-  std::shared_ptr<TcpCallTracer> tcp_tracer_;
 };
 
 /// A list of RPC Contexts
 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,