grpc 1.73.0 → 1.75.0

data/src/core/lib/resource_quota/resource_quota.cc

@@ -16,18 +16,29 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/no_destruct.h"
+#include "src/core/util/single_set_ptr.h"
+
 namespace grpc_core {
 
 ResourceQuota::ResourceQuota(std::string name)
-    : memory_quota_(MakeMemoryQuota(std::move(name))),
+    : channelz_node_(
+          MakeRefCounted<channelz::ResourceQuotaNode>(std::move(name))),
+      memory_quota_(MakeMemoryQuota(channelz_node_)),
       thread_quota_(MakeRefCounted<ThreadQuota>()) {}
 
 ResourceQuota::~ResourceQuota() = default;
 
+namespace {
+NoDestruct<SingleSetRefCountedPtr<ResourceQuota>> default_resource_quota{};
+}  // namespace
+
 ResourceQuotaRefPtr ResourceQuota::Default() {
-  static auto default_resource_quota =
-      MakeResourceQuota("default_resource_quota").release();
-  return default_resource_quota->Ref();
+  return default_resource_quota->GetOrCreate("default_resource_quota");
+}
+
+void ResourceQuota::TestOnlyResetDefaultResourceQuota() {
+  default_resource_quota->Reset();
 }
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/resource_quota.h

@@ -23,6 +23,7 @@
 #include <utility>
 
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/thread_quota.h"
 #include "src/core/util/cpp_impl_of.h"
@@ -53,6 +54,7 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
 
   // The default global resource quota
   static ResourceQuotaRefPtr Default();
+  static void TestOnlyResetDefaultResourceQuota();
 
   static int ChannelArgsCompare(const ResourceQuota* a,
                                 const ResourceQuota* b) {
@@ -60,6 +62,7 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
   }
 
  private:
+  RefCountedPtr<channelz::ResourceQuotaNode> channelz_node_;
   MemoryQuotaRefPtr memory_quota_;
   RefCountedPtr<ThreadQuota> thread_quota_;
 };

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -92,8 +92,7 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
 
 absl::Status GrpcServerAuthzFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, GrpcServerAuthzFilter* filter) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
-      "GrpcServerAuthzFilter::Call::OnClientInitialMetadata");
+  GRPC_LATENT_SEE_SCOPE("GrpcServerAuthzFilter::Call::OnClientInitialMetadata");
   if (!filter->IsAuthorized(md)) {
     return absl::PermissionDeniedError("Unauthorized RPC request rejected.");
   }

data/src/core/lib/slice/slice.h

@@ -294,6 +294,11 @@ class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND MutableSlice
     return MutableSlice(NoCheck{}, grpc_slice_split_head(c_slice_ptr(), n));
   }
 
+  MutableSlice TakeFirstNoInline(size_t n) {
+    return MutableSlice(NoCheck{},
+                        grpc_slice_split_head_no_inline(c_slice_ptr(), n));
+  }
+
   // Iterator access to the underlying bytes
   uint8_t* begin() { return mutable_data(); }
   uint8_t* end() { return mutable_data() + size(); }

data/src/core/lib/surface/call.cc

@@ -490,13 +490,13 @@ grpc_call_error grpc_call_start_batch_and_execute(grpc_call* call,
 }
 
 void grpc_call_tracer_set(grpc_call* call,
-                          grpc_core::ClientCallTracer* tracer) {
-  grpc_core::Arena* arena = grpc_call_get_arena(call);
-  return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
+                          grpc_core::ClientCallTracerInterface* tracer) {
+  grpc_call_get_arena(call)
+      ->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);
 }
 
-void grpc_call_tracer_set_and_manage(grpc_call* call,
-                                     grpc_core::ClientCallTracer* tracer) {
+void grpc_call_tracer_set_and_manage(
+    grpc_call* call, grpc_core::ClientCallTracerInterface* tracer) {
   grpc_core::Arena* arena = grpc_call_get_arena(call);
   arena->ManagedNew<ClientCallTracerWrapper>(tracer);
   return arena->SetContext<grpc_core::CallTracerAnnotationInterface>(tracer);

data/src/core/lib/surface/call.h

@@ -262,7 +262,8 @@ grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 void grpc_call_log_batch(const char* file, int line, const grpc_op* ops,
                          size_t nops);
 
-void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
+void grpc_call_tracer_set(grpc_call* call,
+                          grpc_core::ClientCallTracerInterface* tracer);
 
 // Sets call tracer on the call and manages its life by using the call's arena.
 // When using this API, the tracer will be destroyed by grpc_call arena when
@@ -271,8 +272,8 @@ void grpc_call_tracer_set(grpc_call* call, grpc_core::ClientCallTracer* tracer);
 // Arena to manage the lifetime of the call tracer. Python needs this API
 // because the tracer was created within a separate shared object library which
 // doesn't have access to core functions like arena->ManagedNew<>.
-void grpc_call_tracer_set_and_manage(grpc_call* call,
-                                     grpc_core::ClientCallTracer* tracer);
+void grpc_call_tracer_set_and_manage(
+    grpc_call* call, grpc_core::ClientCallTracerInterface* tracer);
 
 void* grpc_call_tracer_get(grpc_call* call);
 
@@ -287,11 +288,11 @@ uint8_t grpc_call_is_client(grpc_call* call);
 
 class ClientCallTracerWrapper {
  public:
-  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracer* tracer)
+  explicit ClientCallTracerWrapper(grpc_core::ClientCallTracerInterface* tracer)
       : tracer_(tracer) {}
 
  private:
-  std::unique_ptr<grpc_core::ClientCallTracer> tracer_;
+  std::unique_ptr<grpc_core::ClientCallTracerInterface> tracer_;
 };
 
 // Return an appropriate compression algorithm for the requested compression \a

data/src/core/lib/surface/channel_create.cc

@@ -16,6 +16,7 @@
 
 #include "src/core/lib/surface/channel_create.h"
 
+#include <grpc/create_channel_from_endpoint.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
@@ -30,12 +31,19 @@
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/endpoint_channel_arg_wrapper.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/surface/legacy_channel.h"
+#include "src/core/resolver/fake/fake_resolver.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/transport/endpoint_transport.h"
@@ -75,9 +83,7 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     std::string channelz_node_target{target.empty() ? "unknown" : target};
     auto channelz_node = MakeRefCounted<channelz::ChannelNode>(
         channelz_node_target, channel_tracer_max_memory, is_internal_channel);
-    channelz_node->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Channel created"));
+    GRPC_CHANNELZ_LOG(channelz_node) << "Channel created";
     channelz_node->SetChannelArgs(args);
     // Add channelz node to channel args.
     // We remove the is_internal_channel arg, since we no longer need it.
@@ -105,25 +111,24 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
   }
 }
 
-namespace {
 absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
     const char* target, grpc_channel_credentials* creds,
-    const grpc_channel_args* c_args) {
+    const ChannelArgs& args) {
   const auto& c = CoreConfiguration::Get();
   if (target == nullptr) {
     return absl::InternalError("channel target is NULL");
   }
   if (creds == nullptr) return absl::InternalError("No credentials provided");
-  auto args = creds->update_arguments(c.channel_args_preconditioning()
-                                          .PreconditionChannelArgs(c_args)
-                                          .SetObject(creds->Ref()));
+  auto final_args = creds->update_arguments(args.SetObject(creds->Ref()));
   std::vector<absl::string_view> transport_preferences = absl::StrSplit(
-      args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS).value_or("h2"),
+      final_args.GetString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS)
+          .value_or("h2"),
       ',');
   if (transport_preferences.size() != 1) {
     return absl::InternalError(absl::StrCat(
         "Only one preferred transport name is currently supported: requested='",
-        *args.GetOwnedString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS), "'"));
+        *final_args.GetOwnedString(GRPC_ARG_PREFERRED_TRANSPORT_PROTOCOLS),
+        "'"));
   }
   auto* transport =
       c.endpoint_transport_registry().GetTransport(transport_preferences[0]);
@@ -131,10 +136,77 @@ absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
     return absl::InternalError(
         absl::StrCat("Unknown transport '", transport_preferences[0], "'"));
   }
-  return transport->ChannelCreate(target, args);
+  return transport->ChannelCreate(target, final_args);
 }
 
-}  // namespace
+namespace experimental {
+
+using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
+using ::grpc_event_engine::experimental::EndpointChannelArgWrapper;
+using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::EventEngineSupportsFdExtension;
+using ::grpc_event_engine::experimental::QueryExtension;
+
+grpc_channel* CreateChannelFromEndpoint(
+    std::unique_ptr<EventEngine::Endpoint> endpoint,
+    grpc_channel_credentials* creds, const grpc_channel_args* args) {
+  auto address_str = ResolvedAddressToString(endpoint->GetPeerAddress());
+  // TODO(rishesh@) once https://github.com/grpc/grpc/issues/34172 is
+  // resolved, we should use a different address that will be less confusing for
+  // debuggability.
+  grpc_resolved_address address =
+      CreateGRPCResolvedAddress(endpoint->GetPeerAddress());
+  auto response_generator = MakeRefCounted<FakeResolverResponseGenerator>();
+  ChannelArgs channel_args =
+      CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .SetObject(
+              MakeRefCounted<EndpointChannelArgWrapper>(std::move(endpoint)));
+  if (address_str.ok() && !address_str->empty()) {
+    channel_args = channel_args.SetIfUnset(
+        GRPC_ARG_DEFAULT_AUTHORITY, URI::PercentEncodeAuthority(*address_str));
+  }
+  Resolver::Result result;
+  result.args = channel_args;
+  result.addresses = EndpointAddressesList({EndpointAddresses{address, {}}});
+  response_generator->SetResponseAsync(std::move(result));
+  auto r = CreateClientEndpointChannel(
+      "fake:created-from-endpoint", creds,
+      channel_args.SetObject(std::move(response_generator)));
+  if (!r.ok()) {
+    return grpc_lame_client_channel_create(
+        "fake:created-from-endpoint",
+        static_cast<grpc_status_code>(r.status().code()),
+        absl::StrCat(
+            "Failed to create channel to 'fake:created-from-endpoint':",
+            r.status().message())
+            .c_str());
+  }
+  return *r;
+}
+
+grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
+                                  const grpc_channel_args* args) {
+  ChannelArgs channel_args = CoreConfiguration::Get()
+                                 .channel_args_preconditioning()
+                                 .PreconditionChannelArgs(args);
+  EventEngineSupportsFdExtension* supports_fd =
+      QueryExtension<EventEngineSupportsFdExtension>(
+          channel_args.GetObjectRef<EventEngine>().get());
+  if (supports_fd == nullptr) {
+    return grpc_lame_client_channel_create("fake:created-from-endpoint",
+                                           GRPC_STATUS_INTERNAL,
+                                           "Failed to create client channel");
+  }
+  std::unique_ptr<EventEngine::Endpoint> endpoint =
+      supports_fd->CreateEndpointFromFd(
+          fd, ChannelArgsEndpointConfig(channel_args));
+  return CreateChannelFromEndpoint(std::move(endpoint), creds,
+                                   channel_args.ToC().get());
+}
+}  // namespace experimental
+
 }  // namespace grpc_core
 
 grpc_channel* grpc_lame_client_channel_create(const char* target,
@@ -173,7 +245,10 @@ grpc_channel* grpc_channel_create(const char* target,
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_create(target=" << target << ", creds=" << (void*)creds
       << ", args=" << (void*)c_args << ")";
-  auto r = grpc_core::CreateClientEndpointChannel(target, creds, c_args);
+  const auto& c = grpc_core::CoreConfiguration::Get();
+  grpc_core::ChannelArgs channel_args =
+      c.channel_args_preconditioning().PreconditionChannelArgs(c_args);
+  auto r = grpc_core::CreateClientEndpointChannel(target, creds, channel_args);
   if (!r.ok()) {
     return grpc_lame_client_channel_create(
         target, static_cast<grpc_status_code>(r.status().code()),

data/src/core/lib/surface/channel_create.h

@@ -37,6 +37,10 @@ absl::StatusOr<RefCountedPtr<Channel>> ChannelCreate(
     std::string target, ChannelArgs args,
     grpc_channel_stack_type channel_stack_type, Transport* optional_transport);
 
+absl::StatusOr<grpc_channel*> CreateClientEndpointChannel(
+    const char* target, grpc_channel_credentials* creds,
+    const ChannelArgs& args);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_CREATE_H

data/src/core/lib/surface/channel_init.cc

@@ -52,6 +52,23 @@ struct CompareChannelFiltersByName {
     return a.name() < b.name();
   }
 };
+
+struct CompareFusedChannelFiltersByName {
+  bool operator()(ChannelInit::FilterRegistration* a,
+                  ChannelInit::FilterRegistration* b) const {
+    // Sort by descending order based on number of filters contained in the
+    // FusedFilter.
+    int num_filters_a =
+        std::count(a->name().name().begin(), a->name().name().end(), '+') + 1;
+    int num_filters_b =
+        std::count(b->name().name().begin(), b->name().name().end(), '+') + 1;
+    if (num_filters_a == num_filters_b) {
+      return a->name().name() > b->name().name();
+    }
+    return num_filters_a > num_filters_b;
+  }
+};
+
 }  // namespace
 
 ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::After(
@@ -111,6 +128,14 @@ ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
   return *filters_[type].back();
 }
 
+void ChannelInit::Builder::RegisterFusedFilter(
+    grpc_channel_stack_type type, UniqueTypeName name,
+    const grpc_channel_filter* filter, FilterAdder filter_adder,
+    SourceLocation registration_source) {
+  fused_filters_[type].emplace_back(std::make_unique<FilterRegistration>(
+      name, filter, filter_adder, registration_source));
+}
+
 class ChannelInit::DependencyTracker {
  public:
   // Declare that a filter exists.
@@ -232,10 +257,61 @@ class ChannelInit::DependencyTracker {
   size_t nodes_taken_ = 0;
 };
 
-ChannelInit::StackConfig ChannelInit::BuildStackConfig(
+template <bool is_terminal>
+std::vector<ChannelInit::FilterNode> ChannelInit::SelectFiltersByPredicate(
+    const std::vector<Filter>& filters, ChannelStackBuilder* builder) {
+  std::vector<FilterNode> filter_list;
+  int i = 0;
+  // Create an in-place linked list of individual filters
+  for (const auto& filter : filters) {
+    if (!is_terminal && SkipV2(filter.version)) continue;
+    if (!filter.CheckPredicates(builder->channel_args())) continue;
+    filter_list.push_back(FilterNode{&filter, ++i});
+  }
+  if (!filter_list.empty()) {
+    filter_list.back().next = -1;
+  }
+  return filter_list;
+}
+
+void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
+                               const std::vector<Filter>& fused_filters) {
+  int i = 0;
+  int j = 0;
+  // Iterate through fused filters (by size) and check if a given fused filter
+  // can replace one of the existing sequence of filters.
+  for (auto& curr_fused_filter : fused_filters) {
+    i = 0;
+    while (i != -1 && filter_list[i].next != -1) {
+      std::string fused_prefix(filter_list[i].curr->name.name());
+      j = filter_list[i].next;
+      do {
+        absl::StrAppend(&fused_prefix, "+", filter_list[j].curr->name.name());
+        if (fused_prefix == curr_fused_filter.name.name()) {
+          filter_list[i].curr = &curr_fused_filter;
+          filter_list[i].next = filter_list[j].next;
+        }
+        j = filter_list[j].next;
+      } while (j != -1);
+      i = filter_list[i].next;
+    }
+  }
+}
+
+void ChannelInit::AppendFiltersToBuilder(
+    const std::vector<FilterNode>& filter_list, ChannelStackBuilder* builder) {
+  int i = 0;
+  while (i != -1 && !filter_list.empty()) {
+    builder->AppendFilter(filter_list[i].curr->filter);
+    i = filter_list[i].next;
+  };
+}
+
+std::tuple<std::vector<ChannelInit::Filter>, std::vector<ChannelInit::Filter>>
+ChannelInit::SortFilterRegistrationsByDependencies(
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
-        registrations,
-    PostProcessor* post_processors, grpc_channel_stack_type type) {
+        filter_registrations,
+    grpc_channel_stack_type type) {
   // Phase 1: Build a map from filter to the set of filters that must be
   // initialized before it.
   // We order this map (and the set of dependent filters) by filter name to
@@ -244,7 +320,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   // this will help overall stability.
   DependencyTracker dependencies;
   std::vector<Filter> terminal_filters;
-  for (const auto& registration : registrations) {
+  for (const auto& registration : filter_registrations) {
     if (registration->terminal_) {
       CHECK(registration->after_.empty());
       CHECK(registration->before_.empty());
@@ -258,7 +334,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       dependencies.Declare(registration.get());
     }
   }
-  for (const auto& registration : registrations) {
+  for (const auto& registration : filter_registrations) {
     if (registration->terminal_) continue;
     for (UniqueTypeName after : registration->after_) {
       dependencies.InsertEdge(after, registration->name_);
@@ -267,7 +343,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       dependencies.InsertEdge(registration->name_, before);
     }
     if (registration->before_all_) {
-      for (const auto& other : registrations) {
+      for (const auto& other : filter_registrations) {
         if (other.get() == registration.get()) continue;
         if (other->terminal_) continue;
         dependencies.InsertEdge(registration->name_, other->name_);
@@ -286,6 +362,42 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
         std::move(registration->predicates_), registration->version_,
         registration->ordering_, registration->registration_source_);
   }
+  // Log out the graph we built if that's been requested.
+  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
+    PrintChannelStackTrace(type, filter_registrations, dependencies, filters,
+                           terminal_filters);
+  }
+  return std::tuple(std::move(filters), std::move(terminal_filters));
+}
+
+std::vector<ChannelInit::Filter> ChannelInit::SortFusedFilterRegistrations(
+    const std::vector<std::unique_ptr<FilterRegistration>>&
+        filter_registrations) {
+  std::vector<FilterRegistration*> fused_filter_registrations;
+  std::vector<Filter> filters;
+  for (const auto& registration : filter_registrations) {
+    CHECK(!registration->terminal_);
+    fused_filter_registrations.push_back(registration.get());
+  }
+  std::sort(fused_filter_registrations.begin(),
+            fused_filter_registrations.end(),
+            CompareFusedChannelFiltersByName());
+
+  for (auto registration : fused_filter_registrations) {
+    filters.emplace_back(
+        registration->name_, registration->filter_, registration->filter_adder_,
+        std::move(registration->predicates_), registration->version_,
+        registration->ordering_, registration->registration_source_);
+  }
+  return filters;
+}
+
+ChannelInit::StackConfig ChannelInit::BuildStackConfig(
+    const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+        filter_registrations,
+    const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+        fused_filter_registrations,
+    PostProcessor* post_processors, grpc_channel_stack_type type) {
   // Collect post processors that need to be applied.
   // We've already ensured the one-per-slot constraint, so now we can just
   // collect everything up into a vector and run it in order.
@@ -294,27 +406,32 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     if (post_processors[i] == nullptr) continue;
     post_processor_functions.emplace_back(std::move(post_processors[i]));
   }
-  // Log out the graph we built if that's been requested.
-  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
-    PrintChannelStackTrace(type, registrations, dependencies, filters,
-                           terminal_filters);
-  }
+
+  auto sorted_filters =
+      SortFilterRegistrationsByDependencies(filter_registrations, type);
+  std::vector<Filter> filters = std::move(std::get<0>(sorted_filters));
+  std::vector<Filter> terminal_filters = std::move(std::get<1>(sorted_filters));
+
+  std::vector<Filter> fused_filters =
+      SortFusedFilterRegistrations(fused_filter_registrations);
+
   // Check if there are no terminal filters: this would be an error.
-  // GRPC_CLIENT_DYNAMIC stacks don't use this mechanism, so we don't check that
-  // condition here.
-  // Right now we only log: many tests end up with a core configuration that
-  // is invalid.
+  // GRPC_CLIENT_DYNAMIC stacks don't use this mechanism, so we don't check
+  // that condition here. Right now we only log: many tests end up with a
+  // core configuration that is invalid.
   // TODO(ctiller): evaluate if we can turn this into a crash one day.
-  // Right now it forces too many tests to know about channel initialization,
-  // either by supplying a valid configuration or by including an opt-out flag.
+  // Right now it forces too many tests to know about channel
+  // initialization, either by supplying a valid configuration or by
+  // including an opt-out flag.
   if (terminal_filters.empty() && type != GRPC_CLIENT_DYNAMIC) {
-    LOG(ERROR) << "No terminal filters registered for channel stack type "
-               << grpc_channel_stack_type_string(type)
-               << "; this is common for unit tests messing with "
-                  "CoreConfiguration, but will result in a "
-                  "ChannelInit::CreateStack that never completes successfully.";
+    VLOG(2) << "No terminal filters registered for channel stack type "
+            << grpc_channel_stack_type_string(type)
+            << "; this is common for unit tests messing with "
+               "CoreConfiguration, but will result in a "
+               "ChannelInit::CreateStack that never completes successfully.";
   }
-  return StackConfig{std::move(filters), std::move(terminal_filters),
+  return StackConfig{std::move(filters), std::move(fused_filters),
+                     std::move(terminal_filters),
                      std::move(post_processor_functions)};
 };
 
@@ -333,6 +450,7 @@ void ChannelInit::PrintChannelStackTrace(
   MutexLock lock(m);
   // List the channel stack type (since we'll be repeatedly printing graphs in
   // this loop).
+
   LOG(INFO) << "ORDERED CHANNEL STACK " << grpc_channel_stack_type_string(type)
             << ":";
   // First build up a map of filter -> file:line: strings, because it helps
@@ -411,7 +529,7 @@ ChannelInit ChannelInit::Builder::Build() {
   ChannelInit result;
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
     result.stack_configs_[i] =
-        BuildStackConfig(filters_[i], post_processors_[i],
+        BuildStackConfig(filters_[i], fused_filters_[i], post_processors_[i],
                          static_cast<grpc_channel_stack_type>(i));
   }
   return result;
@@ -426,41 +544,40 @@ bool ChannelInit::Filter::CheckPredicates(const ChannelArgs& args) const {
 
 bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
   const auto& stack_config = stack_configs_[builder->channel_stack_type()];
-  for (const auto& filter : stack_config.filters) {
-    if (SkipV2(filter.version)) continue;
-    if (!filter.CheckPredicates(builder->channel_args())) continue;
-    builder->AppendFilter(filter.filter);
-  }
-  int found_terminators = 0;
-  for (const auto& terminator : stack_config.terminators) {
-    if (!terminator.CheckPredicates(builder->channel_args())) continue;
-    builder->AppendFilter(terminator.filter);
-    ++found_terminators;
-  }
-  if (found_terminators != 1) {
+  auto filter_list =
+      SelectFiltersByPredicate<false>(stack_config.filters, builder);
+  auto terminal_filter_list =
+      SelectFiltersByPredicate<true>(stack_config.terminators, builder);
+
+  if (terminal_filter_list.size() != 1) {
+    int filter_count = terminal_filter_list.size();
     std::string error = absl::StrCat(
-        found_terminators,
-        " terminating filters found creating a channel of type ",
+        filter_count, " terminating filters found creating a channel of type ",
         grpc_channel_stack_type_string(builder->channel_stack_type()),
         " with arguments ", builder->channel_args().ToString(),
         " (we insist upon one and only one terminating "
         "filter)\n");
-    if (stack_config.terminators.empty()) {
+    if (terminal_filter_list.empty()) {
       absl::StrAppend(&error, "  No terminal filters were registered");
     } else {
-      for (const auto& terminator : stack_config.terminators) {
-        absl::StrAppend(&error, "  ", terminator.name, " registered @ ",
-                        terminator.registration_source.file(), ":",
-                        terminator.registration_source.line(), ": enabled = ",
-                        terminator.CheckPredicates(builder->channel_args())
-                            ? "true"
-                            : "false",
-                        "\n");
+      for (const auto& terminator : terminal_filter_list) {
+        absl::StrAppend(
+            &error, "  ", terminator.curr->name, " registered @ ",
+            terminator.curr->registration_source.file(), ":",
+            terminator.curr->registration_source.line(), ": enabled = ",
+            terminator.curr->CheckPredicates(builder->channel_args()) ? "true"
+                                                                      : "false",
+            "\n");
       }
     }
     LOG(ERROR) << error;
     return false;
   }
+
+  MergeFilters(filter_list, stack_config.fused_filters);
+  AppendFiltersToBuilder(filter_list, builder);
+  AppendFiltersToBuilder(terminal_filter_list, builder);
+
   for (const auto& post_processor : stack_config.post_processors) {
     post_processor(*builder);
   }