grpc 1.59.2 → 1.60.0.pre1

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

@@ -20,34 +20,387 @@
 
 #include "src/core/lib/surface/channel_init.h"
 
+#include <string.h>
+
 #include <algorithm>
+#include <map>
+#include <set>
+#include <string>
+#include <type_traits>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/channel/channel_stack_trace.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 
 namespace grpc_core {
 
-void ChannelInit::Builder::RegisterStage(grpc_channel_stack_type type,
-                                         int priority, Stage stage) {
-  slots_[type].emplace_back(std::move(stage), priority);
+const char* (*NameFromChannelFilter)(const grpc_channel_filter*);
+
+namespace {
+struct CompareChannelFiltersByName {
+  bool operator()(const grpc_channel_filter* a,
+                  const grpc_channel_filter* b) const {
+    return strcmp(NameFromChannelFilter(a), NameFromChannelFilter(b)) < 0;
+  }
+};
+}  // namespace
+
+ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::After(
+    std::initializer_list<const grpc_channel_filter*> filters) {
+  for (auto filter : filters) {
+    after_.push_back(filter);
+  }
+  return *this;
+}
+
+ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::Before(
+    std::initializer_list<const grpc_channel_filter*> filters) {
+  for (auto filter : filters) {
+    before_.push_back(filter);
+  }
+  return *this;
+}
+
+ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::If(
+    InclusionPredicate predicate) {
+  predicates_.emplace_back(std::move(predicate));
+  return *this;
 }
 
+ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::IfNot(
+    InclusionPredicate predicate) {
+  predicates_.emplace_back(
+      [predicate = std::move(predicate)](const ChannelArgs& args) {
+        return !predicate(args);
+      });
+  return *this;
+}
+
+ChannelInit::FilterRegistration&
+ChannelInit::FilterRegistration::IfHasChannelArg(const char* arg) {
+  return If([arg](const ChannelArgs& args) { return args.Contains(arg); });
+}
+
+ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::IfChannelArg(
+    const char* arg, bool default_value) {
+  return If([arg, default_value](const ChannelArgs& args) {
+    return args.GetBool(arg).value_or(default_value);
+  });
+}
+
+ChannelInit::FilterRegistration&
+ChannelInit::FilterRegistration::ExcludeFromMinimalStack() {
+  return If([](const ChannelArgs& args) { return !args.WantMinimalStack(); });
+}
+
+ChannelInit::FilterRegistration& ChannelInit::Builder::RegisterFilter(
+    grpc_channel_stack_type type, const grpc_channel_filter* filter,
+    SourceLocation registration_source) {
+  filters_[type].emplace_back(
+      std::make_unique<FilterRegistration>(filter, registration_source));
+  return *filters_[type].back();
+}
+
+ChannelInit::StackConfig ChannelInit::BuildStackConfig(
+    const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
+        registrations,
+    PostProcessor* post_processors, 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
+  // ensure algorithm ordering stability is deterministic for a given build.
+  // We should not require this, but at the time of writing it's expected that
+  // this will help overall stability.
+  using F = const grpc_channel_filter*;
+  std::map<F, FilterRegistration*> filter_to_registration;
+  using DependencyMap = std::map<F, std::set<F, CompareChannelFiltersByName>,
+                                 CompareChannelFiltersByName>;
+  DependencyMap dependencies;
+  std::vector<Filter> terminal_filters;
+  for (const auto& registration : registrations) {
+    if (filter_to_registration.count(registration->filter_) > 0) {
+      const auto first =
+          filter_to_registration[registration->filter_]->registration_source_;
+      const auto second = registration->registration_source_;
+      Crash(absl::StrCat("Duplicate registration of channel filter ",
+                         NameFromChannelFilter(registration->filter_),
+                         "\nfirst: ", first.file(), ":", first.line(),
+                         "\nsecond: ", second.file(), ":", second.line()));
+    }
+    filter_to_registration[registration->filter_] = registration.get();
+    if (registration->terminal_) {
+      GPR_ASSERT(registration->after_.empty());
+      GPR_ASSERT(registration->before_.empty());
+      GPR_ASSERT(!registration->before_all_);
+      terminal_filters.emplace_back(registration->filter_,
+                                    std::move(registration->predicates_),
+                                    registration->registration_source_);
+    } else {
+      dependencies[registration->filter_];  // Ensure it's in the map.
+    }
+  }
+  for (const auto& registration : registrations) {
+    if (registration->terminal_) continue;
+    GPR_ASSERT(filter_to_registration.count(registration->filter_) > 0);
+    for (F after : registration->after_) {
+      if (filter_to_registration.count(after) == 0) {
+        gpr_log(
+            GPR_DEBUG, "%s",
+            absl::StrCat(
+                "Filter ", NameFromChannelFilter(after),
+                " not registered, but is referenced in the after clause of ",
+                NameFromChannelFilter(registration->filter_),
+                " when building channel stack ",
+                grpc_channel_stack_type_string(type))
+                .c_str());
+        continue;
+      }
+      dependencies[registration->filter_].insert(after);
+    }
+    for (F before : registration->before_) {
+      if (filter_to_registration.count(before) == 0) {
+        gpr_log(
+            GPR_DEBUG, "%s",
+            absl::StrCat(
+                "Filter ", NameFromChannelFilter(before),
+                " not registered, but is referenced in the before clause of ",
+                NameFromChannelFilter(registration->filter_),
+                " when building channel stack ",
+                grpc_channel_stack_type_string(type))
+                .c_str());
+        continue;
+      }
+      dependencies[before].insert(registration->filter_);
+    }
+    if (registration->before_all_) {
+      for (const auto& other : registrations) {
+        if (other.get() == registration.get()) continue;
+        if (other->terminal_) continue;
+        dependencies[other->filter_].insert(registration->filter_);
+      }
+    }
+  }
+  // Phase 2: Build a list of filters in dependency order.
+  // We can simply iterate through and add anything with no dependency.
+  // We then remove that filter from the dependency list of all other filters.
+  // We repeat until we have no more filters to add.
+  auto build_remaining_dependency_graph =
+      [](const DependencyMap& dependencies) {
+        std::string result;
+        for (const auto& p : dependencies) {
+          absl::StrAppend(&result, NameFromChannelFilter(p.first), " ->");
+          for (const auto& d : p.second) {
+            absl::StrAppend(&result, " ", NameFromChannelFilter(d));
+          }
+          absl::StrAppend(&result, "\n");
+        }
+        return result;
+      };
+  const DependencyMap original = dependencies;
+  auto take_ready_dependency = [&]() {
+    for (auto it = dependencies.begin(); it != dependencies.end(); ++it) {
+      if (it->second.empty()) {
+        auto r = it->first;
+        dependencies.erase(it);
+        return r;
+      }
+    }
+    Crash(absl::StrCat(
+        "Unresolvable graph of channel filters - remaining graph:\n",
+        build_remaining_dependency_graph(dependencies), "original:\n",
+        build_remaining_dependency_graph(original)));
+  };
+  std::vector<Filter> filters;
+  while (!dependencies.empty()) {
+    auto filter = take_ready_dependency();
+    filters.emplace_back(filter,
+                         std::move(filter_to_registration[filter]->predicates_),
+                         filter_to_registration[filter]->registration_source_);
+    for (auto& p : dependencies) {
+      p.second.erase(filter);
+    }
+  }
+  // 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.
+  std::vector<PostProcessor> post_processor_functions;
+  for (int i = 0; i < static_cast<int>(PostProcessorSlot::kCount); i++) {
+    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_channel_stack.enabled()) {
+    // It can happen that multiple threads attempt to construct a core config at
+    // once.
+    // This is benign - the first one wins and others are discarded.
+    // However, it messes up our logging and makes it harder to reason about the
+    // graph, so we add some protection here.
+    static Mutex* const m = new Mutex();
+    MutexLock lock(m);
+    // List the channel stack type (since we'll be repeatedly printing graphs in
+    // this loop).
+    gpr_log(GPR_INFO,
+            "ORDERED CHANNEL STACK %s:", grpc_channel_stack_type_string(type));
+    // First build up a map of filter -> file:line: strings, because it helps
+    // the readability of this log to get later fields aligned vertically.
+    std::map<const grpc_channel_filter*, std::string> loc_strs;
+    size_t max_loc_str_len = 0;
+    size_t max_filter_name_len = 0;
+    auto add_loc_str = [&max_loc_str_len, &loc_strs, &filter_to_registration,
+                        &max_filter_name_len](
+                           const grpc_channel_filter* filter) {
+      max_filter_name_len =
+          std::max(strlen(NameFromChannelFilter(filter)), max_filter_name_len);
+      const auto registration =
+          filter_to_registration[filter]->registration_source_;
+      absl::string_view file = registration.file();
+      auto slash_pos = file.rfind('/');
+      if (slash_pos != file.npos) {
+        file = file.substr(slash_pos + 1);
+      }
+      auto loc_str = absl::StrCat(file, ":", registration.line(), ":");
+      max_loc_str_len = std::max(max_loc_str_len, loc_str.length());
+      loc_strs.emplace(filter, std::move(loc_str));
+    };
+    for (const auto& filter : filters) {
+      add_loc_str(filter.filter);
+    }
+    for (const auto& terminal : terminal_filters) {
+      add_loc_str(terminal.filter);
+    }
+    for (auto& loc_str : loc_strs) {
+      loc_str.second = absl::StrCat(
+          loc_str.second,
+          std::string(max_loc_str_len + 2 - loc_str.second.length(), ' '));
+    }
+    // For each regular filter, print the location registered, the name of the
+    // filter, and if it needed to occur after some other filters list those
+    // filters too.
+    // Note that we use the processed after list here - earlier we turned Before
+    // registrations into After registrations and we used those converted
+    // registrations to build the final ordering.
+    // If you're trying to track down why 'A' is listed as after 'B', look at
+    // the following:
+    //  - If A is registered with .After({B}), then A will be 'after' B here.
+    //  - If B is registered with .Before({A}), then A will be 'after' B here.
+    //  - If B is registered as BeforeAll, then A will be 'after' B here.
+    for (const auto& filter : filters) {
+      auto dep_it = original.find(filter.filter);
+      std::string after_str;
+      if (dep_it != original.end() && !dep_it->second.empty()) {
+        after_str = absl::StrCat(
+            std::string(max_filter_name_len + 1 -
+                            strlen(NameFromChannelFilter(filter.filter)),
+                        ' '),
+            "after ",
+            absl::StrJoin(
+                dep_it->second, ", ",
+                [](std::string* out, const grpc_channel_filter* filter) {
+                  out->append(NameFromChannelFilter(filter));
+                }));
+      }
+      const auto filter_str =
+          absl::StrCat("  ", loc_strs[filter.filter],
+                       NameFromChannelFilter(filter.filter), after_str);
+      gpr_log(GPR_INFO, "%s", filter_str.c_str());
+    }
+    // Finally list out the terminal filters and where they were registered
+    // from.
+    for (const auto& terminal : terminal_filters) {
+      const auto filter_str = absl::StrCat(
+          "  ", loc_strs[terminal.filter],
+          NameFromChannelFilter(terminal.filter),
+          std::string(max_filter_name_len + 1 -
+                          strlen(NameFromChannelFilter(terminal.filter)),
+                      ' '),
+          "[terminal]");
+      gpr_log(GPR_INFO, "%s", filter_str.c_str());
+    }
+  }
+  // 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.
+  // 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.
+  if (terminal_filters.empty() && type != GRPC_CLIENT_DYNAMIC) {
+    gpr_log(
+        GPR_ERROR,
+        "No terminal filters registered for channel stack type %s; this is "
+        "common for unit tests messing with CoreConfiguration, but will result "
+        "in a ChannelInit::CreateStack that never completes successfully.",
+        grpc_channel_stack_type_string(type));
+  }
+  return StackConfig{std::move(filters), std::move(terminal_filters),
+                     std::move(post_processor_functions)};
+};
+
 ChannelInit ChannelInit::Builder::Build() {
   ChannelInit result;
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
-    auto& slots = slots_[i];
-    std::stable_sort(
-        slots.begin(), slots.end(),
-        [](const Slot& a, const Slot& b) { return a.priority < b.priority; });
-    auto& result_slots = result.slots_[i];
-    result_slots.reserve(slots.size());
-    for (auto& slot : slots) {
-      result_slots.emplace_back(std::move(slot.stage));
-    }
+    result.stack_configs_[i] =
+        BuildStackConfig(filters_[i], post_processors_[i],
+                         static_cast<grpc_channel_stack_type>(i));
   }
   return result;
 }
 
+bool ChannelInit::Filter::CheckPredicates(const ChannelArgs& args) const {
+  for (const auto& predicate : predicates) {
+    if (!predicate(args)) return false;
+  }
+  return true;
+}
+
 bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
-  for (const auto& stage : slots_[builder->channel_stack_type()]) {
-    if (!stage(builder)) return false;
+  const auto& stack_config = stack_configs_[builder->channel_stack_type()];
+  for (const auto& filter : stack_config.filters) {
+    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) {
+    std::string error = absl::StrCat(
+        found_terminators,
+        " 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()) {
+      absl::StrAppend(&error, "  No terminal filters were registered");
+    } else {
+      for (const auto& terminator : stack_config.terminators) {
+        absl::StrAppend(
+            &error, "  ", NameFromChannelFilter(terminator.filter),
+            " registered @ ", terminator.registration_source.file(), ":",
+            terminator.registration_source.line(), ": enabled = ",
+            terminator.CheckPredicates(builder->channel_args()) ? "true"
+                                                                : "false",
+            "\n");
+      }
+    }
+    gpr_log(GPR_ERROR, "%s", error.c_str());
+    return false;
+  }
+  for (const auto& post_processor : stack_config.post_processors) {
+    post_processor(*builder);
   }
   return true;
 }

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

@@ -21,16 +21,23 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <initializer_list>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
 
+#include <grpc/support/log.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
-#define GRPC_CHANNEL_INIT_BUILTIN_PRIORITY 10000
-
 /// This module provides a way for plugins (and the grpc core library itself)
 /// to register mutators for channel stacks.
 /// It also provides a universal entry path to run those mutators to build
@@ -38,46 +45,161 @@
 
 namespace grpc_core {
 
+// HACK HACK HACK
+// Right now grpc_channel_filter has a bunch of dependencies high in the stack,
+// but this code needs to live as a dependency of CoreConfiguration so we need
+// to be careful to ensure no dependency loops.
+//
+// We absolutely must be able to get the name from a filter - for stability and
+// for debuggability.
+//
+// So we export this function, and have it filled in by the higher level code at
+// static initialization time.
+//
+// TODO(ctiller): remove this. When we define a FilterFactory type, that type
+// can be specified with the right constraints to be depended upon by this code,
+// and that type can export a `string_view Name()` method.
+extern const char* (*NameFromChannelFilter)(const grpc_channel_filter*);
+
 class ChannelInit {
  public:
-  /// One stage of mutation: call functions against \a builder to influence the
-  /// finally constructed channel stack
-  using Stage = absl::AnyInvocable<bool(ChannelStackBuilder* builder) const>;
+  // Predicate for if a filter registration applies
+  using InclusionPredicate = absl::AnyInvocable<bool(const ChannelArgs&) const>;
+  // Post processor for the channel stack - applied in PostProcessorSlot order
+  using PostProcessor = absl::AnyInvocable<void(ChannelStackBuilder&) const>;
+  // Post processing slots - up to one PostProcessor per slot can be registered
+  // They run after filters registered are added to the channel stack builder,
+  // but before Build is called - allowing ad-hoc mutation to the channel stack.
+  enum class PostProcessorSlot : uint8_t {
+    kAuthSubstitution,
+    kXdsChannelStackModifier,
+    kCount
+  };
+
+  class FilterRegistration {
+   public:
+    explicit FilterRegistration(const grpc_channel_filter* filter,
+                                SourceLocation registration_source)
+        : filter_(filter), registration_source_(registration_source) {}
+    FilterRegistration(const FilterRegistration&) = delete;
+    FilterRegistration& operator=(const FilterRegistration&) = delete;
+
+    // Ensure that this filter is placed *after* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    FilterRegistration& After(
+        std::initializer_list<const grpc_channel_filter*> filters);
+    // Ensure that this filter is placed *before* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    FilterRegistration& Before(
+        std::initializer_list<const grpc_channel_filter*> filters);
+    // Add a predicate for this filters inclusion.
+    // If the predicate returns true the filter will be included in the stack.
+    // Predicates do not affect the ordering of the filter stack: we first
+    // topologically sort (once, globally) and only later apply predicates
+    // per-channel creation.
+    // Multiple predicates can be added to each registration.
+    FilterRegistration& If(InclusionPredicate predicate);
+    FilterRegistration& IfNot(InclusionPredicate predicate);
+    // Add a predicate that only includes this filter if a channel arg is
+    // present.
+    FilterRegistration& IfHasChannelArg(const char* arg);
+    // Add a predicate that only includes this filter if a boolean channel arg
+    // is true (with default_value being used if the argument is not present).
+    FilterRegistration& IfChannelArg(const char* arg, bool default_value);
+    // Mark this filter as being terminal.
+    // Exactly one terminal filter will be added at the end of each filter
+    // stack.
+    // If multiple are defined they are tried in registration order, and the
+    // first terminal filter whos predicates succeed is selected.
+    FilterRegistration& Terminal() {
+      terminal_ = true;
+      return *this;
+    }
+    // Ensure this filter appears at the top of the stack.
+    // Effectively adds a 'Before' constraint on every other filter.
+    // Adding this to more than one filter will cause a loop.
+    FilterRegistration& BeforeAll() {
+      before_all_ = true;
+      return *this;
+    }
+    // Add a predicate that ensures this filter does not appear in the minimal
+    // stack.
+    FilterRegistration& ExcludeFromMinimalStack();
+
+   private:
+    friend class ChannelInit;
+    const grpc_channel_filter* const filter_;
+    std::vector<const grpc_channel_filter*> after_;
+    std::vector<const grpc_channel_filter*> before_;
+    std::vector<InclusionPredicate> predicates_;
+    bool terminal_ = false;
+    bool before_all_ = false;
+    SourceLocation registration_source_;
+  };
 
   class Builder {
    public:
-    /// Register one stage of mutators.
-    /// Stages are run in priority order (lowest to highest), and then in
-    /// registration order (in the case of a tie).
-    /// Stages are registered against one of the pre-determined channel stack
-    /// types.
-    /// If the channel stack type is GRPC_CLIENT_SUBCHANNEL, the caller should
-    /// ensure that subchannels with different filter lists will always have
-    /// different channel args. This requires setting a channel arg in case the
-    /// registration function relies on some condition other than channel args
-    /// to decide whether to add a filter or not.
-    void RegisterStage(grpc_channel_stack_type type, int priority, Stage stage);
-
-    /// Finalize registration. No more calls to grpc_channel_init_register_stage
-    /// are allowed.
+    // Register a builder in the normal filter registration pass.
+    // This occurs first during channel build time.
+    // The FilterRegistration methods can be called to declaratively define
+    // properties of the filter being registered.
+    FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
+                                       const grpc_channel_filter* filter,
+                                       SourceLocation registration_source = {});
+
+    // Register a post processor for the builder.
+    // These run after the main graph has been placed into the builder.
+    // At most one filter per slot per channel stack type can be added.
+    // If at all possible, prefer to use the RegisterFilter() mechanism to add
+    // filters to the system - this should be a last resort escape hatch.
+    void RegisterPostProcessor(grpc_channel_stack_type type,
+                               PostProcessorSlot slot,
+                               PostProcessor post_processor) {
+      auto& slot_value = post_processors_[type][static_cast<int>(slot)];
+      GPR_ASSERT(slot_value == nullptr);
+      slot_value = std::move(post_processor);
+    }
+
+    /// Finalize registration.
     ChannelInit Build();
 
    private:
-    struct Slot {
-      Slot(Stage stage, int priority)
-          : stage(std::move(stage)), priority(priority) {}
-      Stage stage;
-      int priority;
-    };
-    std::vector<Slot> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];
+    std::vector<std::unique_ptr<FilterRegistration>>
+        filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
+    PostProcessor post_processors_[GRPC_NUM_CHANNEL_STACK_TYPES]
+                                  [static_cast<int>(PostProcessorSlot::kCount)];
   };
 
   /// Construct a channel stack of some sort: see channel_stack.h for details
   /// \a builder is the channel stack builder to build into.
+  GRPC_MUST_USE_RESULT
   bool CreateStack(ChannelStackBuilder* builder) const;
 
  private:
-  std::vector<Stage> slots_[GRPC_NUM_CHANNEL_STACK_TYPES];
+  struct Filter {
+    Filter(const grpc_channel_filter* filter,
+           std::vector<InclusionPredicate> predicates,
+           SourceLocation registration_source)
+        : filter(filter),
+          predicates(std::move(predicates)),
+          registration_source(registration_source) {}
+    const grpc_channel_filter* filter;
+    std::vector<InclusionPredicate> predicates;
+    SourceLocation registration_source;
+    bool CheckPredicates(const ChannelArgs& args) const;
+  };
+  struct StackConfig {
+    std::vector<Filter> filters;
+    std::vector<Filter> terminators;
+    std::vector<PostProcessor> post_processors;
+  };
+  StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
+
+  static StackConfig BuildStackConfig(
+      const std::vector<std::unique_ptr<FilterRegistration>>& registrations,
+      PostProcessor* post_processors, grpc_channel_stack_type type);
 };
 
 }  // namespace grpc_core

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

@@ -24,7 +24,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <initializer_list>
 #include <new>
 #include <string>
 #include <utility>
@@ -886,12 +885,6 @@ void grpc_cq_end_op(grpc_completion_queue* cq, void* tag,
                     void (*done)(void* done_arg, grpc_cq_completion* storage),
                     void* done_arg, grpc_cq_completion* storage,
                     bool internal) {
-// TODO(hork): remove when the listener flake is identified
-#ifdef GPR_WINDOWS
-  if (grpc_core::IsEventEngineListenerEnabled()) {
-    gpr_log(GPR_ERROR, "cq_end_op called for tag %d (0x%p)", tag, tag);
-  }
-#endif
   cq->vtable->end_op(cq, tag, error, done, done_arg, storage, internal);
 }
 

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

@@ -21,7 +21,6 @@
 #include "src/core/lib/surface/event_string.h"
 
 #include <algorithm>
-#include <initializer_list>
 #include <vector>
 
 #include "absl/strings/str_format.h"