grpc 1.75.0 → 1.78.1

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

@@ -26,12 +26,12 @@
 #include <string>
 #include <vector>
 
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/util/string.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 static void add_metadata(const grpc_metadata* md, size_t count,
                          std::vector<std::string>* b) {

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

@@ -40,12 +40,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/status_util.h"
@@ -60,7 +54,13 @@
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -215,7 +215,7 @@ bool ValidateMetadata(size_t count, grpc_metadata* metadata) {
 void EndOpImmediately(grpc_completion_queue* cq, void* notify_tag,
                       bool is_notify_tag_closure) {
   if (!is_notify_tag_closure) {
-    CHECK(grpc_cq_begin_op(cq, notify_tag));
+    GRPC_CHECK(grpc_cq_begin_op(cq, notify_tag));
     grpc_cq_end_op(
         cq, notify_tag, absl::OkStatus(),
         [](void*, grpc_cq_completion* completion) { gpr_free(completion); },

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

@@ -36,25 +36,32 @@
 #include <algorithm>
 #include <atomic>
 #include <cstdint>
+#include <cstring>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/cancel_callback.h"
+#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/upb_utils.h"
+#include "src/proto/grpc/channelz/v2/promise.upb.h"
+#include "upb/mem/arena.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -238,6 +245,32 @@ class OpHandlerImpl {
     PromiseFactory promise_factory_;
     Promise promise_;
   };
+
+ public:
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    auto* custom_promise =
+        grpc_channelz_v2_Promise_mutable_custom_promise(promise_proto, arena);
+    std::string type = absl::StrCat("OpHandlerImpl<", OpName(), ">");
+    grpc_channelz_v2_Promise_Custom_set_type(
+        custom_promise, CopyStdStringToUpbString(type, arena));
+    channelz::PropertyList properties;
+    switch (state_) {
+      case State::kDismissed:
+        properties.Set("state", "dismissed");
+        break;
+      case State::kPromiseFactory:
+        properties.Set("state", "promise_factory");
+        break;
+      case State::kPromise:
+        properties.Set("state", "promise");
+        properties.Set("promise", PromiseProperty(&promise_));
+        break;
+    }
+    properties.FillUpbProto(grpc_channelz_v2_Promise_Custom_mutable_properties(
+                                custom_promise, arena),
+                            arena);
+  }
 };
 
 template <grpc_op_type op_type, typename PromiseFactory>
@@ -289,6 +322,21 @@ class BatchOpIndex {
 // to Empty{}
 class WaitForCqEndOp {
  public:
+  struct NotStarted {
+    bool is_closure;
+    void* tag;
+    grpc_error_handle error;
+    grpc_completion_queue* cq;
+  };
+  struct Started {
+    explicit Started(Waker waker) : waker(std::move(waker)) {}
+    Waker waker;
+    grpc_cq_completion completion;
+    std::atomic<bool> done{false};
+  };
+  struct Invalid {};
+  using State = std::variant<NotStarted, Started, Invalid>;
+
   WaitForCqEndOp(bool is_closure, void* tag, grpc_error_handle error,
                  grpc_completion_queue* cq)
       : state_{NotStarted{is_closure, tag, std::move(error), cq}} {}
@@ -308,24 +356,35 @@ class WaitForCqEndOp {
   }
 
  private:
-  struct NotStarted {
-    bool is_closure;
-    void* tag;
-    grpc_error_handle error;
-    grpc_completion_queue* cq;
-  };
-  struct Started {
-    explicit Started(Waker waker) : waker(std::move(waker)) {}
-    Waker waker;
-    grpc_cq_completion completion;
-    std::atomic<bool> done{false};
-  };
-  struct Invalid {};
-  using State = std::variant<NotStarted, Started, Invalid>;
-
   static std::string StateString(const State& state);
 
   State state_{Invalid{}};
+
+ public:
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    auto* custom_promise =
+        grpc_channelz_v2_Promise_mutable_custom_promise(promise_proto, arena);
+    grpc_channelz_v2_Promise_Custom_set_type(
+        custom_promise, CopyStdStringToUpbString("WaitForCqEndOp", arena));
+    channelz::PropertyList properties;
+    std::visit(
+        [&properties](const auto& s) {
+          using T = std::decay_t<decltype(s)>;
+          if constexpr (std::is_same_v<T, NotStarted>) {
+            properties.Set("state", "not_started");
+          } else if constexpr (std::is_same_v<T, Started>) {
+            properties.Set("state", "started");
+            properties.Set("done", s.done.load(std::memory_order_relaxed));
+          } else if constexpr (std::is_same_v<T, Invalid>) {
+            properties.Set("state", "invalid");
+          }
+        },
+        state_);
+    properties.FillUpbProto(grpc_channelz_v2_Promise_Custom_mutable_properties(
+                                custom_promise, arena),
+                            arena);
+  }
 };
 
 template <typename FalliblePart, typename FinalPart>
@@ -406,6 +465,12 @@ class PollBatchLogger {
 
   void* tag_;
   F f_;
+
+ public:
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    PromiseAsProto(f_, promise_proto, arena);
+  }
 };
 
 template <typename F>
@@ -428,7 +493,7 @@ class MessageReceiver {
 
   template <typename Puller>
   auto MakeBatchOp(const grpc_op& op, Puller* puller) {
-    CHECK_EQ(recv_message_, nullptr);
+    GRPC_CHECK_EQ(recv_message_, nullptr);
     recv_message_ = op.data.recv_message.recv_message;
     return [this, puller]() mutable {
       return Map(puller->PullMessage(),

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

@@ -22,7 +22,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -31,6 +30,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -67,7 +67,8 @@ Channel::Channel(std::string target, const ChannelArgs& channel_args)
           channel_args.GetObject<ResourceQuota>()
               ->memory_quota()
               ->CreateMemoryOwner(),
-          1024)) {}
+          1024)),
+      memory_allocator_(&call_arena_allocator_->allocator()) {}
 
 Channel::RegisteredCall* Channel::RegisterCall(const char* method,
                                                const char* host) {
@@ -102,7 +103,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
                                     grpc_completion_queue* completion_queue,
                                     grpc_slice method, const grpc_slice* host,
                                     gpr_timespec deadline, void* reserved) {
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->CreateCall(
       parent_call, propagation_mask, completion_queue, nullptr,
@@ -119,7 +120,7 @@ void* grpc_channel_register_call(grpc_channel* channel, const char* method,
   GRPC_TRACE_LOG(api, INFO) << "grpc_channel_register_call(channel=" << channel
                             << ", method=" << method << ", host=" << host
                             << ", reserved=" << reserved << ")";
-  CHECK(!reserved);
+  GRPC_CHECK(!reserved);
   grpc_core::ExecCtx exec_ctx;
   return grpc_core::Channel::FromC(channel)->RegisterCall(method, host);
 }
@@ -208,6 +209,6 @@ void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_channel_ping(channel=" << channel << ", cq=" << cq
       << ", tag=" << tag << ", reserved=" << reserved << ")";
-  CHECK_EQ(reserved, nullptr);
+  GRPC_CHECK_EQ(reserved, nullptr);
   grpc_core::Channel::FromC(channel)->Ping(cq, tag);
 }

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

@@ -18,6 +18,7 @@
 #define GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_H
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
 #include <grpc/support/port_platform.h>
@@ -27,13 +28,11 @@
 #include <optional>
 #include <string>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -45,6 +44,9 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 // Forward declaration to avoid dependency loop.
 struct grpc_channel_stack;
@@ -130,6 +132,13 @@ class Channel : public UnstartedCallDestination,
     return call_arena_allocator_.get();
   }
 
+  grpc_event_engine::experimental::MemoryAllocator* memory_allocator() const {
+    if (IsTrackWritesInResourceQuotaEnabled()) {
+      return memory_allocator_;
+    }
+    return nullptr;
+  }
+
  protected:
   Channel(std::string target, const ChannelArgs& channel_args);
 
@@ -145,6 +154,7 @@ class Channel : public UnstartedCallDestination,
   std::map<std::pair<std::string, std::string>, RegisteredCall>
       registration_table_ ABSL_GUARDED_BY(mu_);
   const RefCountedPtr<CallArenaAllocator> call_arena_allocator_;
+  grpc_event_engine::experimental::MemoryAllocator* memory_allocator_ = nullptr;
 };
 
 }  // namespace grpc_core

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

@@ -21,9 +21,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_split.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/direct_channel.h"
@@ -47,6 +44,9 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/transport/endpoint_transport.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
 
 namespace grpc_core {
 
@@ -199,10 +199,14 @@ grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
                                            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,
+  auto endpoint = supports_fd->CreateEndpointFromFd(
+      fd, ChannelArgsEndpointConfig(channel_args));
+  if (!endpoint.ok()) {
+    return grpc_lame_client_channel_create(
+        "fake:created-from-endpoint", GRPC_STATUS_INTERNAL,
+        std::string(endpoint.status().message()).c_str());
+  }
+  return CreateChannelFromEndpoint(std::move(endpoint).value(), creds,
                                    channel_args.ToC().get());
 }
 }  // namespace experimental
@@ -230,7 +234,7 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
   auto channel =
       grpc_core::ChannelCreate(target == nullptr ? "" : target, std::move(args),
                                GRPC_CLIENT_LAME_CHANNEL, nullptr);
-  CHECK(channel.ok());
+  GRPC_CHECK(channel.ok());
   return channel->release()->c_ptr();
 }
 

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

@@ -21,10 +21,10 @@
 
 #include <string>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "absl/status/statusor.h"
 
 #define GRPC_ARG_USE_V3_STACK "grpc.internal.use_v3_stack"
 

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

@@ -28,17 +28,20 @@
 #include <set>
 #include <string>
 #include <type_traits>
+#include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -69,6 +72,11 @@ struct CompareFusedChannelFiltersByName {
   }
 };
 
+struct Node {
+  const grpc_channel_filter* filter;
+  int next;
+};
+
 }  // namespace
 
 ChannelInit::FilterRegistration& ChannelInit::FilterRegistration::After(
@@ -177,9 +185,8 @@ class ChannelInit::DependencyTracker {
 
   FilterRegistration* Next() {
     if (ready_dependencies_.empty()) {
-      CHECK_EQ(nodes_taken_, nodes_.size()) << "Unresolvable graph of channel "
-                                               "filters:\n"
-                                            << GraphString();
+      GRPC_CHECK_EQ(nodes_taken_, nodes_.size())
+          << "Unresolvable graph of channel filters :\n " << GraphString();
       return nullptr;
     }
     auto next = ready_dependencies_.top();
@@ -189,13 +196,13 @@ class ChannelInit::DependencyTracker {
       // Constraint: if we use ordering other than default, then we must have an
       // unambiguous pick. If there is ambiguity, we must fix it by adding
       // explicit ordering constraints.
-      CHECK_NE(next.node->ordering(),
-               ready_dependencies_.top().node->ordering())
+      GRPC_CHECK_NE(next.node->ordering(),
+                    ready_dependencies_.top().node->ordering())
           << "Ambiguous ordering between " << next.node->name() << " and "
           << ready_dependencies_.top().node->name();
     }
     for (Node* dependent : next.node->dependents) {
-      CHECK_GT(dependent->waiting_dependencies, 0u);
+      GRPC_CHECK_GT(dependent->waiting_dependencies, 0u);
       --dependent->waiting_dependencies;
       if (dependent->waiting_dependencies == 0) {
         ready_dependencies_.emplace(dependent);
@@ -220,7 +227,7 @@ class ChannelInit::DependencyTracker {
 
   absl::Span<const UniqueTypeName> DependenciesFor(UniqueTypeName name) const {
     auto it = nodes_.find(name);
-    CHECK(it != nodes_.end()) << "Filter " << name.name() << " not found";
+    GRPC_CHECK(it != nodes_.end()) << "Filter " << name.name() << " not found";
     return it->second.all_dependencies;
   }
 
@@ -274,21 +281,29 @@ std::vector<ChannelInit::FilterNode> ChannelInit::SelectFiltersByPredicate(
   return filter_list;
 }
 
-void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
-                               const std::vector<Filter>& fused_filters) {
+void ChannelInit::MergeFusedFilters(ChannelStackBuilder* builder,
+                                    const std::vector<Filter>& fused_filters) {
   int i = 0;
   int j = 0;
+  auto& stack = *builder->mutable_stack();
+  std::vector<Node> filter_list;
+  for (const auto& [filter, _] : stack) {
+    filter_list.push_back({filter, ++i});
+  }
+  filter_list.back().next = -1;
   // 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());
+      std::string fused_prefix(
+          NameFromChannelFilter(filter_list[i].filter).name());
       j = filter_list[i].next;
       do {
-        absl::StrAppend(&fused_prefix, "+", filter_list[j].curr->name.name());
+        absl::StrAppend(&fused_prefix, "+",
+                        NameFromChannelFilter(filter_list[j].filter).name());
         if (fused_prefix == curr_fused_filter.name.name()) {
-          filter_list[i].curr = &curr_fused_filter;
+          filter_list[i].filter = curr_fused_filter.filter;
           filter_list[i].next = filter_list[j].next;
         }
         j = filter_list[j].next;
@@ -296,6 +311,13 @@ void ChannelInit::MergeFilters(std::vector<FilterNode>& filter_list,
       i = filter_list[i].next;
     }
   }
+  // Replace the stack with the new filter list.
+  stack.clear();
+  i = 0;
+  while (i != -1 && !filter_list.empty()) {
+    builder->AppendFilter(filter_list[i].filter);
+    i = filter_list[i].next;
+  };
 }
 
 void ChannelInit::AppendFiltersToBuilder(
@@ -311,7 +333,7 @@ std::tuple<std::vector<ChannelInit::Filter>, std::vector<ChannelInit::Filter>>
 ChannelInit::SortFilterRegistrationsByDependencies(
     const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&
         filter_registrations,
-    grpc_channel_stack_type type) {
+    grpc_channel_stack_type type, channelz::PropertyTable& filter_ordering) {
   // 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
@@ -322,10 +344,10 @@ ChannelInit::SortFilterRegistrationsByDependencies(
   std::vector<Filter> terminal_filters;
   for (const auto& registration : filter_registrations) {
     if (registration->terminal_) {
-      CHECK(registration->after_.empty());
-      CHECK(registration->before_.empty());
-      CHECK(!registration->before_all_);
-      CHECK_EQ(registration->ordering_, Ordering::kDefault);
+      GRPC_CHECK(registration->after_.empty());
+      GRPC_CHECK(registration->before_.empty());
+      GRPC_CHECK(!registration->before_all_);
+      GRPC_CHECK_EQ(registration->ordering_, Ordering::kDefault);
       terminal_filters.emplace_back(
           registration->name_, registration->filter_, nullptr,
           std::move(registration->predicates_), registration->version_,
@@ -362,6 +384,19 @@ ChannelInit::SortFilterRegistrationsByDependencies(
         std::move(registration->predicates_), registration->version_,
         registration->ordering_, registration->registration_source_);
   }
+
+  for (const auto& filter : filters) {
+    auto after = dependencies.DependenciesFor(filter.name);
+    std::string ordering_str;
+    if (!after.empty()) {
+      ordering_str = absl::StrCat("after ", absl::StrJoin(after, ", "));
+    }
+    absl::StrAppend(&ordering_str, " [", filter.ordering, "/", filter.version,
+                    "]");
+    filter_ordering.AppendRow(channelz::PropertyList()
+                                  .Set("name", filter.name.name())
+                                  .Set("ordering", ordering_str));
+  }
   // Log out the graph we built if that's been requested.
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     PrintChannelStackTrace(type, filter_registrations, dependencies, filters,
@@ -376,7 +411,7 @@ std::vector<ChannelInit::Filter> ChannelInit::SortFusedFilterRegistrations(
   std::vector<FilterRegistration*> fused_filter_registrations;
   std::vector<Filter> filters;
   for (const auto& registration : filter_registrations) {
-    CHECK(!registration->terminal_);
+    GRPC_CHECK(!registration->terminal_);
     fused_filter_registrations.push_back(registration.get());
   }
   std::sort(fused_filter_registrations.begin(),
@@ -406,9 +441,10 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
     if (post_processors[i] == nullptr) continue;
     post_processor_functions.emplace_back(std::move(post_processors[i]));
   }
+  channelz::PropertyTable filter_ordering;
 
-  auto sorted_filters =
-      SortFilterRegistrationsByDependencies(filter_registrations, type);
+  auto sorted_filters = SortFilterRegistrationsByDependencies(
+      filter_registrations, type, filter_ordering);
   std::vector<Filter> filters = std::move(std::get<0>(sorted_filters));
   std::vector<Filter> terminal_filters = std::move(std::get<1>(sorted_filters));
 
@@ -432,7 +468,7 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   }
   return StackConfig{std::move(filters), std::move(fused_filters),
                      std::move(terminal_filters),
-                     std::move(post_processor_functions)};
+                     std::move(post_processor_functions), filter_ordering};
 };
 
 void ChannelInit::PrintChannelStackTrace(
@@ -574,13 +610,17 @@ bool ChannelInit::CreateStack(ChannelStackBuilder* builder) const {
     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);
   }
+
+  // Only perform the merge with fused filters operation after running
+  // through all the post processors. This ensures that modifications made by
+  // post processors are taken into account before finding fusions to match.
+  MergeFusedFilters(builder, stack_config.fused_filters);
   return true;
 }
 
@@ -600,4 +640,21 @@ void ChannelInit::AddToInterceptionChainBuilder(
   }
 }
 
+void ChannelInit::AddData(channelz::DataSink sink,
+                          grpc_channel_stack_type type) const {
+  const auto& stack_config = stack_configs_[type];
+  sink.AddData(
+      "channel_stack_filters",
+      channelz::PropertyList().Set("elements", stack_config.filter_ordering));
+  sink.AddData("fused_filters",
+               channelz::PropertyList().Set("elements", [&stack_config]() {
+                 channelz::PropertyTable elements;
+                 for (const auto& filter : stack_config.fused_filters) {
+                   elements.AppendRow(channelz::PropertyList().Set(
+                       "name", filter.name.name()));
+                 }
+                 return elements;
+               }()));
+}
+
 }  // namespace grpc_core