grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
 #define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
@@ -26,36 +26,39 @@
 // the C++ API in src/cpp/common/channel_filter.{h,cc}
 //////////////////////////////////////////////////////////////////////////////
 
-/* A channel filter defines how operations on a channel are implemented.
-   Channel filters are chained together to create full channels, and if those
-   chains are linear, then channel stacks provide a mechanism to minimize
-   allocations for that chain.
-   Call stacks are created by channel stacks and represent the per-call data
-   for that stack.
-
-   Implementations should take care of the following details for a batch -
-   1. Synchronization is achieved with a CallCombiner. View
-   src/core/lib/iomgr/call_combiner.h for more details.
-   2. If the filter wants to inject an error on the way down, it needs to call
-   grpc_transport_stream_op_batch_finish_with_failure from within the call
-   combiner. This will cause any batch callbacks to be called with that error.
-   3. If the filter wants to inject an error on the way up (from a callback), it
-   should also inject that error in the recv_trailing_metadata callback so that
-   it can have an effect on the call status.
-*/
+// A channel filter defines how operations on a channel are implemented.
+// Channel filters are chained together to create full channels, and if those
+// chains are linear, then channel stacks provide a mechanism to minimize
+// allocations for that chain.
+// Call stacks are created by channel stacks and represent the per-call data
+// for that stack.
+
+// Implementations should take care of the following details for a batch -
+// 1. Synchronization is achieved with a CallCombiner. View
+// src/core/lib/iomgr/call_combiner.h for more details.
+// 2. If the filter wants to inject an error on the way down, it needs to call
+// grpc_transport_stream_op_batch_finish_with_failure from within the call
+// combiner. This will cause any batch callbacks to be called with that error.
+// 3. If the filter wants to inject an error on the way up (from a callback), it
+// should also inject that error in the recv_trailing_metadata callback so that
+// it can have an effect on the call status.
+//
 
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 
 #include <functional>
+#include <memory>
 
-#include <grpc/impl/codegen/gpr_types.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
@@ -89,122 +92,121 @@ struct grpc_call_element_args {
 };
 struct grpc_call_stats {
   grpc_transport_stream_stats transport_stream_stats;
-  gpr_timespec latency; /* From call creating to enqueing of received status */
+  gpr_timespec latency;  // From call creating to enqueing of received status
 };
-/** Information about the call upon completion. */
+/// Information about the call upon completion.
 struct grpc_call_final_info {
   grpc_call_stats stats;
   grpc_status_code final_status = GRPC_STATUS_OK;
   const char* error_string = nullptr;
 };
 
-/* Channel filters specify:
-   1. the amount of memory needed in the channel & call (via the sizeof_XXX
-      members)
-   2. functions to initialize and destroy channel & call data
-      (init_XXX, destroy_XXX)
-   3. functions to implement call operations and channel operations (call_op,
-      channel_op)
-   4. a name, which is useful when debugging
+// Channel filters specify:
+// 1. the amount of memory needed in the channel & call (via the sizeof_XXX
+//    members)
+// 2. functions to initialize and destroy channel & call data
+//    (init_XXX, destroy_XXX)
+// 3. functions to implement call operations and channel operations (call_op,
+//    channel_op)
+// 4. a name, which is useful when debugging
 
-   Members are laid out in approximate frequency of use order. */
+// Members are laid out in approximate frequency of use order.
 struct grpc_channel_filter {
-  /* Called to eg. send/receive data on a call.
-     See grpc_call_next_op on how to call the next element in the stack */
+  // Called to eg. send/receive data on a call.
+  // See grpc_call_next_op on how to call the next element in the stack
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* op);
-  /* Create a promise to execute one call.
-     If this is non-null, it may be used in preference to
-     start_transport_stream_op_batch.
-     If this is used in preference to start_transport_stream_op_batch, the
-     following can be omitted also:
-       - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
-       - allocation of memory for call data
-     There is an on-going migration to move all filters to providing this, and
-     then to drop start_transport_stream_op_batch. */
+  // Create a promise to execute one call.
+  // If this is non-null, it may be used in preference to
+  // start_transport_stream_op_batch.
+  // If this is used in preference to start_transport_stream_op_batch, the
+  // following can be omitted also:
+  //   - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
+  //   - allocation of memory for call data
+  // There is an on-going migration to move all filters to providing this, and
+  // then to drop start_transport_stream_op_batch.
   grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
       grpc_channel_element* elem, grpc_core::CallArgs call_args,
       grpc_core::NextPromiseFactory next_promise_factory);
-  /* Called to handle channel level operations - e.g. new calls, or transport
-     closure.
-     See grpc_channel_next_op on how to call the next element in the stack */
+  // Called to handle channel level operations - e.g. new calls, or transport
+  // closure.
+  // See grpc_channel_next_op on how to call the next element in the stack
   void (*start_transport_op)(grpc_channel_element* elem, grpc_transport_op* op);
 
-  /* sizeof(per call data) */
+  // sizeof(per call data)
   size_t sizeof_call_data;
-  /* Initialize per call data.
-     elem is initialized at the start of the call, and elem->call_data is what
-     needs initializing.
-     The filter does not need to do any chaining.
-     server_transport_data is an opaque pointer. If it is NULL, this call is
-     on a client; if it is non-NULL, then it points to memory owned by the
-     transport and is on the server. Most filters want to ignore this
-     argument.
-     Implementations may assume that elem->call_data is all zeros. */
+  // Initialize per call data.
+  // elem is initialized at the start of the call, and elem->call_data is what
+  // needs initializing.
+  // The filter does not need to do any chaining.
+  // server_transport_data is an opaque pointer. If it is NULL, this call is
+  // on a client; if it is non-NULL, then it points to memory owned by the
+  // transport and is on the server. Most filters want to ignore this
+  // argument.
+  // Implementations may assume that elem->call_data is all zeros.
   grpc_error_handle (*init_call_elem)(grpc_call_element* elem,
                                       const grpc_call_element_args* args);
   void (*set_pollset_or_pollset_set)(grpc_call_element* elem,
                                      grpc_polling_entity* pollent);
-  /* Destroy per call data.
-     The filter does not need to do any chaining.
-     The bottom filter of a stack will be passed a non-NULL pointer to
-     \a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
-     destruction is complete. \a final_info contains data about the completed
-     call, mainly for reporting purposes. */
+  // Destroy per call data.
+  // The filter does not need to do any chaining.
+  // The bottom filter of a stack will be passed a non-NULL pointer to
+  // \a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
+  // destruction is complete. \a final_info contains data about the completed
+  // call, mainly for reporting purposes.
   void (*destroy_call_elem)(grpc_call_element* elem,
                             const grpc_call_final_info* final_info,
                             grpc_closure* then_schedule_closure);
 
-  /* sizeof(per channel data) */
+  // sizeof(per channel data)
   size_t sizeof_channel_data;
-  /* Initialize per-channel data.
-     elem is initialized at the creating of the channel, and elem->channel_data
-     is what needs initializing.
-     is_first, is_last designate this elements position in the stack, and are
-     useful for asserting correct configuration by upper layer code.
-     The filter does not need to do any chaining.
-     Implementations may assume that elem->channel_data is all zeros. */
+  // Initialize per-channel data.
+  // elem is initialized at the creating of the channel, and elem->channel_data
+  // is what needs initializing.
+  // is_first, is_last designate this elements position in the stack, and are
+  // useful for asserting correct configuration by upper layer code.
+  // The filter does not need to do any chaining.
+  // Implementations may assume that elem->channel_data is all zeros.
   grpc_error_handle (*init_channel_elem)(grpc_channel_element* elem,
                                          grpc_channel_element_args* args);
-  /* Post init per-channel data.
-     Called after all channel elements have been successfully created. */
+  // Post init per-channel data.
+  // Called after all channel elements have been successfully created.
   void (*post_init_channel_elem)(grpc_channel_stack* stk,
                                  grpc_channel_element* elem);
-  /* Destroy per channel data.
-     The filter does not need to do any chaining */
+  // Destroy per channel data.
+  // The filter does not need to do any chaining
   void (*destroy_channel_elem)(grpc_channel_element* elem);
 
-  /* Implement grpc_channel_get_info() */
+  // Implement grpc_channel_get_info()
   void (*get_channel_info)(grpc_channel_element* elem,
                            const grpc_channel_info* channel_info);
 
-  /* The name of this filter */
+  // The name of this filter
   const char* name;
 };
-/* A channel_element tracks its filter and the filter requested memory within
-   a channel allocation */
+// A channel_element tracks its filter and the filter requested memory within
+// a channel allocation
 struct grpc_channel_element {
   const grpc_channel_filter* filter;
   void* channel_data;
 };
 
-/* A call_element tracks its filter, the filter requested memory within
-   a channel allocation, and the filter requested memory within a call
-   allocation */
+// A call_element tracks its filter, the filter requested memory within
+// a channel allocation, and the filter requested memory within a call
+// allocation
 struct grpc_call_element {
   const grpc_channel_filter* filter;
   void* channel_data;
   void* call_data;
 };
 
-/* A channel stack tracks a set of related filters for one channel, and
-   guarantees they live within a single malloc() allocation */
+// A channel stack tracks a set of related filters for one channel, and
+// guarantees they live within a single malloc() allocation
 struct grpc_channel_stack {
   grpc_stream_refcount refcount;
-  bool is_client;
   size_t count;
-  /* Memory required for a call stack (computed at channel stack
-     initialization) */
+  // Memory required for a call stack (computed at channel stack
+  // initialization)
   size_t call_stack_size;
   // TODO(ctiller): remove this mechanism... it's a hack to allow
   // Channel to be separated from grpc_channel_stack's allocation. As the
@@ -212,6 +214,14 @@ struct grpc_channel_stack {
   // should look like and this can go.
   grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
+  grpc_core::ManualConstructor<
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>>
+      event_engine;
+
+  grpc_event_engine::experimental::EventEngine* EventEngine() const {
+    return event_engine->get();
+  }
+
   // Minimal infrastructure to act like a RefCounted thing without converting
   // everything.
   // It's likely that we'll want to replace grpc_channel_stack with something
@@ -224,17 +234,19 @@ struct grpc_channel_stack {
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
 
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> MakeCallPromise(
-      grpc_core::CallArgs call_args);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeClientCallPromise(grpc_core::CallArgs call_args);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeServerCallPromise(grpc_core::CallArgs call_args);
 };
 
-/* A call stack tracks a set of related filters for one call, and guarantees
-   they live within a single malloc() allocation */
+// A call stack tracks a set of related filters for one call, and guarantees
+// they live within a single malloc() allocation
 struct grpc_call_stack {
-  /* shared refcount for this channel stack.
-     MUST be the first element: the underlying code calls destroy
-     with the address of the refcount, but higher layers prefer to think
-     about the address of the call stack itself. */
+  // shared refcount for this channel stack.
+  // MUST be the first element: the underlying code calls destroy
+  // with the address of the refcount, but higher layers prefer to think
+  // about the address of the call stack itself.
   grpc_stream_refcount refcount;
   size_t count;
 
@@ -249,10 +261,10 @@ struct grpc_call_stack {
   }
 };
 
-/* Get a channel element given a channel stack and its index */
+// Get a channel element given a channel stack and its index
 grpc_channel_element* grpc_channel_stack_element(grpc_channel_stack* stack,
                                                  size_t i);
-/* Get the last channel element in a channel stack */
+// Get the last channel element in a channel stack
 grpc_channel_element* grpc_channel_stack_last_element(
     grpc_channel_stack* stack);
 
@@ -262,30 +274,31 @@ grpc_channel_element* grpc_channel_stack_last_element(
 size_t grpc_channel_stack_filter_instance_number(
     grpc_channel_stack* channel_stack, grpc_channel_element* elem);
 
-/* Get a call stack element given a call stack and an index */
+// Get a call stack element given a call stack and an index
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 
-/* Determine memory required for a channel stack containing a set of filters */
+// Determine memory required for a channel stack containing a set of filters
 size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count);
-/* Initialize a channel stack given some filters */
+// Initialize a channel stack given some filters
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* args, const char* name, grpc_channel_stack* stack);
-/* Destroy a channel stack */
+    const grpc_core::ChannelArgs& args, const char* name,
+    grpc_channel_stack* stack);
+// Destroy a channel stack
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 
-/* Initialize a call stack given a channel stack. transport_server_data is
-   expected to be NULL on a client, or an opaque transport owned pointer on the
-   server. */
+// Initialize a call stack given a channel stack. transport_server_data is
+// expected to be NULL on a client, or an opaque transport owned pointer on the
+// server.
 grpc_error_handle grpc_call_stack_init(grpc_channel_stack* channel_stack,
                                        int initial_refs,
                                        grpc_iomgr_cb_func destroy,
                                        void* destroy_arg,
                                        const grpc_call_element_args* elem_args);
-/* Set a pollset or a pollset_set for a call stack: must occur before the first
- * op is started */
+// Set a pollset or a pollset_set for a call stack: must occur before the first
+// op is started
 void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
                                                 grpc_polling_entity* pollent);
 
@@ -337,29 +350,29 @@ inline void grpc_call_stack::Unref() {
   GRPC_CALL_STACK_UNREF(this, "smart_pointer");
 }
 
-/* Destroy a call stack */
+// Destroy a call stack
 void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,
                              grpc_closure* then_schedule_closure);
 
-/* Ignore set pollset{_set} - used by filters if they don't care about pollsets
- * at all. Does nothing. */
+// Ignore set pollset{_set} - used by filters if they don't care about pollsets
+// at all. Does nothing.
 void grpc_call_stack_ignore_set_pollset_or_pollset_set(
     grpc_call_element* elem, grpc_polling_entity* pollent);
-/* Call the next operation in a call stack */
+// Call the next operation in a call stack
 void grpc_call_next_op(grpc_call_element* elem,
                        grpc_transport_stream_op_batch* op);
-/* Call the next operation (depending on call directionality) in a channel
-   stack */
+// Call the next operation (depending on call directionality) in a channel
+// stack
 void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op);
-/* Pass through a request to get_channel_info() to the next child element */
+// Pass through a request to get_channel_info() to the next child element
 void grpc_channel_next_get_info(grpc_channel_element* elem,
                                 const grpc_channel_info* channel_info);
 
-/* Given the top element of a channel stack, get the channel stack itself */
+// Given the top element of a channel stack, get the channel stack itself
 grpc_channel_stack* grpc_channel_stack_from_top_element(
     grpc_channel_element* elem);
-/* Given the top element of a call stack, get the call stack itself */
+// Given the top element of a call stack, get the call stack itself
 grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem);
 
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
@@ -378,4 +391,4 @@ extern grpc_core::TraceFlag grpc_trace_channel;
     }                                                  \
   } while (0)
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H */
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -26,7 +26,10 @@
 
 namespace grpc_core {
 
-ChannelStackBuilder::~ChannelStackBuilder() = default;
+ChannelStackBuilder::ChannelStackBuilder(const char* name,
+                                         grpc_channel_stack_type type,
+                                         const ChannelArgs& channel_args)
+    : name_(name), type_(type), args_(channel_args) {}
 
 ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   if (target == nullptr) {
@@ -37,12 +40,6 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
-    const ChannelArgs& args) {
-  args_ = args;
-  return *this;
-}
-
 void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
   stack_.insert(stack_.begin(), filter);
 }

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

@@ -41,8 +41,9 @@ namespace grpc_core {
 class ChannelStackBuilder {
  public:
   // Initialize with a name.
-  ChannelStackBuilder(const char* name, grpc_channel_stack_type type)
-      : name_(name), type_(type) {}
+  // channel_args *must be* preconditioned already.
+  ChannelStackBuilder(const char* name, grpc_channel_stack_type type,
+                      const ChannelArgs& channel_args);
 
   const char* name() const { return name_; }
 
@@ -62,15 +63,17 @@ class ChannelStackBuilder {
   // Query the transport.
   grpc_transport* transport() const { return transport_; }
 
-  // Set channel args.
-  ChannelStackBuilder& SetChannelArgs(const ChannelArgs& args);
-
   // Query the channel args.
   const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
   std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
 
+  // Immutable vector of proposed stack entries.
+  const std::vector<const grpc_channel_filter*>& stack() const {
+    return stack_;
+  }
+
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
 
@@ -80,6 +83,11 @@ class ChannelStackBuilder {
   // Helper to add a filter to the end of the stack.
   void AppendFilter(const grpc_channel_filter* filter);
 
+  // Determine whether a promise-based call stack is able to be built.
+  // Iterates each filter and ensures that there's a promise factory there.
+  // This will go away once the promise conversion is completed.
+  virtual bool IsPromising() const = 0;
+
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
@@ -88,7 +96,7 @@ class ChannelStackBuilder {
   virtual absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() = 0;
 
  protected:
-  ~ChannelStackBuilder();
+  ~ChannelStackBuilder() = default;
 
  private:
   static std::string unknown_target() { return "unknown"; }

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -22,29 +22,48 @@
 
 #include <string.h>
 
+#include <algorithm>
 #include <vector>
 
 #include "absl/status/status.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/support/alloc.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"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
+bool ChannelStackBuilderImpl::IsPromising() const {
+  for (const auto* filter : stack()) {
+    if (filter->make_call_promise == nullptr) return false;
+  }
+  return true;
+}
+
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
 ChannelStackBuilderImpl::Build() {
-  auto* stack = mutable_stack();
+  std::vector<const grpc_channel_filter*> stack;
+  const bool is_promising = IsPromising();
+
+  for (const auto* filter : this->stack()) {
+    if (is_promising && grpc_call_trace.enabled()) {
+      stack.push_back(PromiseTracingFilterFor(filter));
+    }
+    stack.push_back(filter);
+  }
 
   // calculate the size of the channel stack
   size_t channel_stack_size =
-      grpc_channel_stack_size(stack->data(), stack->size());
+      grpc_channel_stack_size(stack.data(), stack.size());
 
   // allocate memory
   auto* channel_stack =
@@ -72,19 +91,18 @@ ChannelStackBuilderImpl::Build() {
         grpc_channel_stack_destroy(stk);
         gpr_free(stk);
       },
-      channel_stack, stack->data(), stack->size(), final_args.ToC().get(),
-      name(), channel_stack);
+      channel_stack, stack.data(), stack.size(), final_args, name(),
+      channel_stack);
 
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(channel_stack);
     auto status = grpc_error_to_absl_status(error);
-    GRPC_ERROR_UNREF(error);
     return status;
   }
 
   // run post-initialization functions
-  for (size_t i = 0; i < stack->size(); i++) {
+  for (size_t i = 0; i < stack.size(); i++) {
     auto* elem = grpc_channel_stack_element(channel_stack, i);
     elem->filter->post_init_channel_elem(channel_stack, elem);
   }