grpc 1.71.0 → 1.74.0

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

@@ -30,12 +30,12 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "src/core/call/call_filters.h"
+#include "src/core/call/interception_chain.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/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_filters.h"
-#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/unique_type_name.h"
 
@@ -270,6 +270,8 @@ class ChannelInit {
       return *this;
     }
 
+    const UniqueTypeName& name() { return name_; }
+
    private:
     friend class ChannelInit;
     const UniqueTypeName name_;
@@ -322,6 +324,34 @@ class ChannelInit {
           .SkipV3();
     }
 
+    // Register a builder in the normal fused 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.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
+    void RegisterFusedFilter(grpc_channel_stack_type type, UniqueTypeName name,
+                             const grpc_channel_filter* filter,
+                             FilterAdder filter_adder = nullptr,
+                             SourceLocation registration_source = {});
+
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             const grpc_channel_filter* filter,
+                             SourceLocation registration_source = {}) {
+      CHECK(filter != nullptr);
+      RegisterFusedFilter(type, NameFromChannelFilter(filter), filter, nullptr,
+                          registration_source);
+    }
+
+    template <typename Filter>
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             SourceLocation registration_source = {}) {
+      RegisterFusedFilter(
+          type, UniqueTypeNameFor<Filter>(), &Filter::kFilter,
+          [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
+          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.
@@ -341,6 +371,8 @@ class ChannelInit {
    private:
     std::vector<std::unique_ptr<FilterRegistration>>
         filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
+    std::vector<std::unique_ptr<FilterRegistration>>
+        fused_filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
     PostProcessor post_processors_[GRPC_NUM_CHANNEL_STACK_TYPES]
                                   [static_cast<int>(PostProcessorSlot::kCount)];
   };
@@ -382,17 +414,48 @@ class ChannelInit {
     Ordering ordering;
     bool CheckPredicates(const ChannelArgs& args) const;
   };
+
+  struct FilterNode {
+    const Filter* curr;
+    int next;
+  };
+
   struct StackConfig {
     std::vector<Filter> filters;
+    std::vector<Filter> fused_filters;
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
   };
 
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
 
+  static std::tuple<std::vector<Filter>, std::vector<Filter>>
+  SortFilterRegistrationsByDependencies(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      grpc_channel_stack_type type);
+
+  static std::vector<Filter> SortFusedFilterRegistrations(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations);
+
+  template <bool is_terminal>
+  static std::vector<FilterNode> SelectFiltersByPredicate(
+      const std::vector<Filter>& filters, ChannelStackBuilder* builder);
+
+  static void MergeFilters(std::vector<FilterNode>& filter_list,
+                           const std::vector<Filter>& fused_filters);
+
+  static void AppendFiltersToBuilder(const std::vector<FilterNode>& filter_list,
+                                     ChannelStackBuilder* builder);
+
   static StackConfig BuildStackConfig(
-      const std::vector<std::unique_ptr<FilterRegistration>>& registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          fused_filter_registrations,
       PostProcessor* post_processors, grpc_channel_stack_type type);
+
   static void PrintChannelStackTrace(
       grpc_channel_stack_type type,
       const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&

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

@@ -17,18 +17,17 @@
 //
 #include "src/core/lib/surface/completion_queue.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-#include <inttypes.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <atomic>
-#include <new>
 #include <string>
 #include <utility>
 #include <vector>
@@ -38,11 +37,9 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/surface/event_string.h"
 #include "src/core/telemetry/stats.h"
@@ -54,10 +51,6 @@
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
 
-#ifdef GPR_WINDOWS
-#include "src/core/lib/experiments/experiments.h"
-#endif
-
 namespace {
 
 // Specifies a cq thread local cache.
@@ -73,7 +66,7 @@ struct plucker {
   void* tag;
 };
 struct cq_poller_vtable {
-  bool can_get_pollset;
+  bool (*can_get_pollset)();
   bool can_listen;
   size_t (*size)(void);
   void (*init)(grpc_pollset* pollset, gpr_mu** mu);
@@ -186,16 +179,83 @@ void non_polling_poller_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   }
 }
 
+bool non_polling_poller_can_never_get_pollset() { return false; }
+
+bool maybe_event_engine_poller_can_get_pollset() {
+  return !grpc_event_engine::experimental::UsePollsetAlternative();
+}
+
+// maybe_event_engine*: If iomgr isn't relied upon for polling, then we can use
+// the non-polling poller implementations below.
+size_t maybe_event_engine_poller_size(void) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_size();
+  } else {
+    return grpc_pollset_size();
+  }
+}
+
+void maybe_event_engine_poller_init(grpc_pollset* pollset, gpr_mu** mu) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_init(pollset, mu);
+  } else {
+    grpc_pollset_init(pollset, mu);
+  }
+}
+
+void maybe_event_engine_poller_destroy(grpc_pollset* pollset) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_destroy(pollset);
+  } else {
+    grpc_pollset_destroy(pollset);
+  }
+}
+
+grpc_error_handle maybe_event_engine_pollset_work(
+    grpc_pollset* pollset, grpc_pollset_worker** worker,
+    grpc_core::Timestamp deadline) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_work(pollset, worker, deadline);
+  } else {
+    return grpc_pollset_work(pollset, worker, deadline);
+  }
+}
+
+grpc_error_handle maybe_event_engine_poller_kick(
+    grpc_pollset* pollset, grpc_pollset_worker* specific_worker) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    return non_polling_poller_kick(pollset, specific_worker);
+  } else {
+    return grpc_pollset_kick(pollset, specific_worker);
+  }
+}
+
+void maybe_event_engine_poller_shutdown(grpc_pollset* pollset,
+                                        grpc_closure* closure) {
+  if (grpc_event_engine::experimental::UsePollsetAlternative()) {
+    non_polling_poller_shutdown(pollset, closure);
+  } else {
+    grpc_pollset_shutdown(pollset, closure);
+  }
+}
+
+// TODO(hork): Once EE is the default everywhere, the only variations will be
+// the bool args controlling whether the poller can get a pollset and whether it
+// can listen.
 const cq_poller_vtable g_poller_vtable_by_poller_type[] = {
     // GRPC_CQ_DEFAULT_POLLING
-    {true, true, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
-     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
+    {maybe_event_engine_poller_can_get_pollset, true,
+     maybe_event_engine_poller_size, maybe_event_engine_poller_init,
+     maybe_event_engine_poller_kick, maybe_event_engine_pollset_work,
+     maybe_event_engine_poller_shutdown, maybe_event_engine_poller_destroy},
     // GRPC_CQ_NON_LISTENING
-    {true, false, grpc_pollset_size, grpc_pollset_init, grpc_pollset_kick,
-     grpc_pollset_work, grpc_pollset_shutdown, grpc_pollset_destroy},
+    {maybe_event_engine_poller_can_get_pollset, false,
+     maybe_event_engine_poller_size, maybe_event_engine_poller_init,
+     maybe_event_engine_poller_kick, maybe_event_engine_pollset_work,
+     maybe_event_engine_poller_shutdown, maybe_event_engine_poller_destroy},
     // GRPC_CQ_NON_POLLING
-    {false, false, non_polling_poller_size, non_polling_poller_init,
-     non_polling_poller_kick, non_polling_poller_work,
+    {non_polling_poller_can_never_get_pollset, false, non_polling_poller_size,
+     non_polling_poller_init, non_polling_poller_kick, non_polling_poller_work,
      non_polling_poller_shutdown, non_polling_poller_destroy},
 };
 
@@ -1372,7 +1432,7 @@ void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
 }
 
 grpc_pollset* grpc_cq_pollset(grpc_completion_queue* cq) {
-  return cq->poller_vtable->can_get_pollset ? POLLSET_FROM_CQ(cq) : nullptr;
+  return cq->poller_vtable->can_get_pollset() ? POLLSET_FROM_CQ(cq) : nullptr;
 }
 
 bool grpc_cq_can_listen(grpc_completion_queue* cq) {

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

@@ -40,8 +40,10 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -57,7 +59,6 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -114,6 +115,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   *out_call = call->c_ptr();
   grpc_slice path = grpc_empty_slice();
   ScopedContext ctx(call);
+  Call* parent = Call::FromC(args->parent);
   if (call->is_client()) {
     call->final_op_.client.status_details = nullptr;
     call->final_op_.client.status = nullptr;
@@ -129,8 +131,15 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     call->send_initial_metadata_.Set(
         GrpcRegisteredMethod(), reinterpret_cast<void*>(static_cast<uintptr_t>(
                                     args->registered_method)));
-    channel_stack->stats_plugin_group->AddClientCallTracers(
-        Slice(CSliceRef(path)), args->registered_method, arena.get());
+    if (parent != nullptr) {
+      add_init_error(&error, absl_status_to_grpc_error(call->InitParent(
+                                 parent, args->propagation_mask)));
+    }
+    // Client call tracers should be created after propagating relevant
+    // properties (tracing included) from the parent.
+    (*channel_stack->stats_plugin_group)
+        ->AddClientCallTracers(Slice(CSliceRef(path)), args->registered_method,
+                               arena.get());
   } else {
     global_stats().IncrementServerCallsCreated();
     call->final_op_.server.cancelled = nullptr;
@@ -157,19 +166,14 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
         arena->SetContext<CallTracerInterface>(server_call_tracer);
       }
     }
-    channel_stack->stats_plugin_group->AddServerCallTracers(arena.get());
+    (*channel_stack->stats_plugin_group)->AddServerCallTracers(arena.get());
   }
 
-  Call* parent = Call::FromC(args->parent);
-  if (parent != nullptr) {
-    add_init_error(&error, absl_status_to_grpc_error(call->InitParent(
-                               parent, args->propagation_mask)));
-  }
   // initial refcount dropped by grpc_call_unref
   grpc_call_element_args call_args = {
-      call->call_stack(),   args->server_transport_data, path,
-      call->start_time(),   call->send_deadline(),       call->arena(),
-      &call->call_combiner_};
+      call->call_stack(), args->server_transport_data,
+      call->start_time(), call->send_deadline(),
+      call->arena(),      &call->call_combiner_};
   add_init_error(&error, grpc_call_stack_init(channel_stack, 1, DestroyCall,
                                               call, &call_args));
   // Publish this call to parent only after the call stack has been initialized.
@@ -273,7 +277,7 @@ void FilterStackCall::ExternalUnref() {
   destroy_called_ = true;
   bool cancel = gpr_atm_acq_load(&received_final_op_atm_) == 0;
   if (cancel) {
-    CancelWithError(absl::CancelledError());
+    CancelWithError(absl::CancelledError("CANCELLED"));
   } else {
     // Unset the call combiner cancellation closure.  This has the
     // effect of scheduling the previously set cancellation closure, if
@@ -395,18 +399,26 @@ bool FilterStackCall::PrepareApplicationMetadata(size_t count,
       is_trailing ? &send_trailing_metadata_ : &send_initial_metadata_;
   for (size_t i = 0; i < count; i++) {
     grpc_metadata* md = &metadata[i];
-    if (!GRPC_LOG_IF_ERROR("validate_metadata",
-                           grpc_validate_header_key_is_legal(md->key))) {
-      return false;
-    } else if (!grpc_is_binary_header_internal(md->key) &&
-               !GRPC_LOG_IF_ERROR(
-                   "validate_metadata",
-                   grpc_validate_header_nonbin_value_is_legal(md->value))) {
+    if (auto status = grpc_validate_header_key_is_legal(md->key);
+        !status.ok()) {
+      LOG(ERROR) << "Metadata key '"
+                 << absl::CEscape(StringViewFromSlice(md->key))
+                 << "' is invalid: " << status;
       return false;
-    } else if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
+    }
+    if (!grpc_is_binary_header_internal(md->key)) {
+      if (auto status = grpc_validate_header_nonbin_value_is_legal(md->value);
+          !status.ok()) {
+        LOG(ERROR) << "Metadata value for key " << StringViewFromSlice(md->key)
+                   << " is invalid: " << status;
+        return false;
+      }
+    }
+    if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
       // HTTP2 hpack encoding has a maximum limit.
       return false;
-    } else if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
+    }
+    if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
       // Filter "content-length metadata"
       continue;
     }
@@ -451,21 +463,31 @@ void FilterStackCall::RecvTrailingFilter(grpc_metadata_batch* b,
   } else {
     std::optional<grpc_status_code> grpc_status = b->Take(GrpcStatusMetadata());
     if (grpc_status.has_value()) {
-      grpc_status_code status_code = *grpc_status;
       grpc_error_handle error;
-      if (status_code != GRPC_STATUS_OK) {
-        Slice peer = GetPeerString();
-        error = grpc_error_set_int(
-            GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
-                                           peer.as_string_view())),
-            StatusIntProperty::kRpcStatus, static_cast<intptr_t>(status_code));
-      }
-      auto grpc_message = b->Take(GrpcMessageMetadata());
-      if (grpc_message.has_value()) {
-        error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
-                                   grpc_message->as_string_view());
-      } else if (!error.ok()) {
-        error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
+      if (IsErrorFlattenEnabled()) {
+        auto grpc_message = b->Take(GrpcMessageMetadata());
+        absl::string_view message;
+        if (grpc_message.has_value()) message = grpc_message->as_string_view();
+        error =
+            absl::Status(static_cast<absl::StatusCode>(*grpc_status), message);
+      } else {
+        grpc_status_code status_code = *grpc_status;
+        if (status_code != GRPC_STATUS_OK) {
+          Slice peer = GetPeerString();
+          error = grpc_error_set_int(
+              GRPC_ERROR_CREATE(absl::StrCat("Error received from peer ",
+                                             peer.as_string_view())),
+              StatusIntProperty::kRpcStatus,
+              static_cast<intptr_t>(status_code));
+        }
+        auto grpc_message = b->Take(GrpcMessageMetadata());
+        if (grpc_message.has_value()) {
+          error = grpc_error_set_str(error, StatusStrProperty::kGrpcMessage,
+                                     grpc_message->as_string_view());
+        } else if (!error.ok()) {
+          error =
+              grpc_error_set_str(error, StatusStrProperty::kGrpcMessage, "");
+        }
       }
       SetFinalStatus(error);
     } else if (!is_client()) {

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

@@ -42,6 +42,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -51,7 +52,6 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"

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

@@ -33,6 +33,8 @@
 #include "absl/time/time.h"
 #include "src/core/client_channel/backup_poller.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/security_connector.h"
+#include "src/core/filter/auth/auth_filters.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/experiments/config.h"
@@ -41,9 +43,6 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/security/authorization/grpc_server_authz_filter.h"
-#include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/security_connector/security_connector.h"
-#include "src/core/lib/security/transport/auth_filters.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/fork.h"
@@ -72,21 +71,12 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
-  if (IsCallv3ClientAuthFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  } else {
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  }
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
@@ -181,14 +171,14 @@ void grpc_shutdown(void) {
         !grpc_event_engine::experimental::TimerManager::
             IsTimerManagerThread() &&
         grpc_core::ExecCtx::Get() == nullptr) {
-      // just run clean-up when this is called on non-executor thread.
+      // just run clean-up when this is called on non-EventEngine thread.
       VLOG(2) << "grpc_shutdown starts clean-up now";
       g_shutting_down = true;
       grpc_shutdown_internal_locked();
       VLOG(2) << "grpc_shutdown done";
     } else {
       // spawn a detached thread to do the actual clean up in case we are
-      // currently in an executor thread.
+      // currently in an EventEngine thread.
       VLOG(2) << "grpc_shutdown spawns clean-up thread";
       g_initializations++;
       g_shutting_down = true;

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

@@ -28,6 +28,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
@@ -40,7 +41,6 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted_ptr.h"

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

@@ -63,7 +63,7 @@ namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
     std::string target, ChannelArgs args,
-    grpc_channel_stack_type channel_stack_type) {
+    grpc_channel_stack_type channel_stack_type, const Blackboard* blackboard) {
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
     auto channel_args_mutator =
         grpc_channel_args_get_client_channel_creation_mutator();
@@ -71,26 +71,10 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
       args = channel_args_mutator(target.c_str(), args, channel_stack_type);
     }
   }
-  ChannelStackBuilderImpl builder(
-      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
-      args);
-  builder.SetTarget(target.c_str());
-  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
-    return nullptr;
-  }
-  // Only need to update stats for server channels here.  Stats for client
-  // channels are handled in our base class.
-  if (builder.channel_stack_type() == GRPC_SERVER_CHANNEL) {
-    global_stats().IncrementServerChannelsCreated();
-  }
-  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
-  if (!r.ok()) {
-    auto status = r.status();
-    LOG(ERROR) << "channel stack builder failed: " << status;
-    return status;
-  }
+  std::shared_ptr<GlobalStatsPluginRegistry::StatsPluginGroup>
+      stats_plugin_group;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
-    *(*r)->stats_plugin_group =
+    stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForServer(args);
     // Add per-server stats plugins.
     auto* stats_plugin_list = args.GetPointer<
@@ -98,8 +82,8 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
     if (stats_plugin_list != nullptr) {
       for (const auto& plugin : **stats_plugin_list) {
-        (*r)->stats_plugin_group->AddStatsPlugin(
-            plugin, plugin->GetServerScopeConfig(args));
+        stats_plugin_group->AddStatsPlugin(plugin,
+                                           plugin->GetServerScopeConfig(args));
       }
     }
   } else {
@@ -111,7 +95,7 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         args);
     experimental::StatsPluginChannelScope scope(target, authority,
                                                 endpoint_config);
-    *(*r)->stats_plugin_group =
+    stats_plugin_group =
         GlobalStatsPluginRegistry::GetStatsPluginsForChannel(scope);
     // Add per-channel stats plugins.
     auto* stats_plugin_list = args.GetPointer<
@@ -119,11 +103,32 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
         GRPC_ARG_EXPERIMENTAL_STATS_PLUGINS);
     if (stats_plugin_list != nullptr) {
       for (const auto& plugin : **stats_plugin_list) {
-        (*r)->stats_plugin_group->AddStatsPlugin(
+        stats_plugin_group->AddStatsPlugin(
             plugin, plugin->GetChannelScopeConfig(scope));
       }
     }
   }
+  args = args.SetObject(stats_plugin_group);
+  ChannelStackBuilderImpl builder(
+      grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
+      args);
+  builder.SetTarget(target.c_str());
+  builder.SetBlackboard(blackboard);
+  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
+    return nullptr;
+  }
+  // Only need to update stats for server channels here.  Stats for client
+  // channels are handled in our base class.
+  if (builder.channel_stack_type() == GRPC_SERVER_CHANNEL) {
+    global_stats().IncrementServerChannelsCreated();
+  }
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> r = builder.Build();
+  if (!r.ok()) {
+    auto status = r.status();
+    LOG(ERROR) << "channel stack builder failed: " << status;
+    return status;
+  }
+  *(*r)->stats_plugin_group = std::move(stats_plugin_group);
   return MakeRefCounted<LegacyChannel>(
       grpc_channel_stack_type_is_client(builder.channel_stack_type()),
       std::move(target), args, std::move(*r));
@@ -157,10 +162,7 @@ LegacyChannel::LegacyChannel(bool is_client, std::string target,
     node = channelz_node()->RefAsSubclass<channelz::ChannelNode>();
   }
   *channel_stack_->on_destroy = [node = std::move(node)]() {
-    if (node != nullptr) {
-      node->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                          grpc_slice_from_static_string("Channel destroyed"));
-    }
+    GRPC_CHANNELZ_LOG(node) << "Channel destroyed";
     ShutdownInternally();
   };
 }

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

@@ -27,7 +27,9 @@
 #include <string>
 
 #include "absl/status/statusor.h"
+#include "src/core/call/call_arena_allocator.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
@@ -35,7 +37,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_arena_allocator.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -47,7 +48,8 @@ class LegacyChannel final : public Channel {
  public:
   static absl::StatusOr<RefCountedPtr<Channel>> Create(
       std::string target, ChannelArgs args,
-      grpc_channel_stack_type channel_stack_type);
+      grpc_channel_stack_type channel_stack_type,
+      const Blackboard* blackboard = nullptr);
 
   // Do not instantiate directly -- use Create() instead.
   LegacyChannel(bool is_client, std::string target,

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "46.0.0"; }
+const char* grpc_version_string(void) { return "49.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gears"; }
+const char* grpc_g_stands_for(void) { return "gee"; }