grpc 1.64.3 → 1.65.0

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

@@ -29,6 +29,7 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -36,11 +37,10 @@
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 
@@ -264,8 +264,7 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   if (v == nullptr) return absl::nullopt;
   auto i = v->GetIfInt();
   if (!i.has_value()) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
-            std::string(name).c_str());
+    LOG(ERROR) << name << " ignored: it must be an integer";
     return absl::nullopt;
   }
   switch (*i) {
@@ -274,8 +273,8 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
     case 1:
       return true;
     default:
-      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
-              std::string(name).c_str(), *i);
+      LOG(ERROR) << name << " treated as bool but set to " << *i
+                 << " (assuming true)";
       return true;
   }
 }
@@ -557,17 +556,15 @@ int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options) {
   if (arg == nullptr) return options.default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an integer";
     return options.default_value;
   }
   if (arg->value.integer < options.min_value) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be >= %d", arg->key,
-            options.min_value);
+    LOG(ERROR) << arg->key << " ignored: it must be >= " << options.min_value;
     return options.default_value;
   }
   if (arg->value.integer > options.max_value) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be <= %d", arg->key,
-            options.max_value);
+    LOG(ERROR) << arg->key << " ignored: it must be <= " << options.max_value;
     return options.default_value;
   }
   return arg->value.integer;
@@ -583,7 +580,7 @@ int grpc_channel_args_find_integer(const grpc_channel_args* args,
 char* grpc_channel_arg_get_string(const grpc_arg* arg) {
   if (arg == nullptr) return nullptr;
   if (arg->type != GRPC_ARG_STRING) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an string", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an string";
     return nullptr;
   }
   return arg->value.string;
@@ -598,7 +595,7 @@ char* grpc_channel_args_find_string(const grpc_channel_args* args,
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
   if (arg == nullptr) return default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+    LOG(ERROR) << arg->key << " ignored: it must be an integer";
     return default_value;
   }
   switch (arg->value.integer) {
@@ -607,8 +604,8 @@ bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
     case 1:
       return true;
     default:
-      gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
-              arg->key, arg->value.integer);
+      LOG(ERROR) << arg->key << " treated as bool but set to "
+                 << arg->value.integer << " (assuming true)";
       return true;
   }
 }
@@ -667,8 +664,7 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
     if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
         key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
       if (src->args[i].type != GRPC_ARG_STRING) {
-        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
-                std::string(key).c_str());
+        LOG(ERROR) << "Channel argument '" << key << "' should be a string";
       } else {
         concatenated_values[key].push_back(src->args[i].value.string);
       }

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

@@ -38,7 +38,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/avl/avl.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -46,6 +45,7 @@
 #include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/util/useful.h"
 
 // TODO(hork): When we're ready to allow setting via a channel arg from the
 // application, replace this with a macro in
@@ -83,6 +83,16 @@ inline int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
 // before the crt refcount base class.
 template <typename T>
 using RefType = absl::remove_cvref_t<decltype(*std::declval<T>().Ref())>;
+
+template <typename T, typename Ignored = void /* for SFINAE */>
+struct IsRawPointerTagged {
+  static constexpr bool kValue = false;
+};
+template <typename T>
+struct IsRawPointerTagged<T,
+                          absl::void_t<typename T::RawPointerChannelArgTag>> {
+  static constexpr bool kValue = true;
+};
 }  // namespace channel_args_detail
 
 // Specialization for ref-counted pointers.
@@ -91,13 +101,14 @@ using RefType = absl::remove_cvref_t<decltype(*std::declval<T>().Ref())>;
 template <typename T>
 struct ChannelArgTypeTraits<
     T, absl::enable_if_t<
-           std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
-                           channel_args_detail::RefType<T>>::value ||
-               std::is_base_of<RefCounted<channel_args_detail::RefType<T>,
-                                          NonPolymorphicRefCount>,
-                               channel_args_detail::RefType<T>>::value ||
-               std::is_base_of<DualRefCounted<channel_args_detail::RefType<T>>,
-                               channel_args_detail::RefType<T>>::value,
+           !channel_args_detail::IsRawPointerTagged<T>::kValue &&
+               (std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
+                                channel_args_detail::RefType<T>>::value ||
+                std::is_base_of<RefCounted<channel_args_detail::RefType<T>,
+                                           NonPolymorphicRefCount>,
+                                channel_args_detail::RefType<T>>::value ||
+                std::is_base_of<DualRefCounted<channel_args_detail::RefType<T>>,
+                                channel_args_detail::RefType<T>>::value),
            void>> {
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {

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

@@ -24,20 +24,18 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/channel_stack_trace.h"
-#include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/util/alloc.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
-grpc_core::TraceFlag grpc_trace_channel(false, "channel");
-
 static int register_get_name_fn = []() {
   grpc_core::NameFromChannelFilter = [](const grpc_channel_filter* filter) {
     return filter->name;
@@ -120,11 +118,10 @@ grpc_error_handle grpc_channel_stack_init(
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& channel_args, const char* name,
     grpc_channel_stack* stack) {
-  if (grpc_trace_channel_stack.enabled()) {
-    gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
+  if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
+    LOG(INFO) << "CHANNEL_STACK: init " << name;
     for (size_t i = 0; i < filter_count; i++) {
-      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s%s", filters[i]->name,
-              filters[i]->make_call_promise ? " [promise-capable]" : "");
+      LOG(INFO) << "CHANNEL_STACK:   filter " << filters[i]->name;
     }
   }
 
@@ -296,61 +293,6 @@ grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
 void grpc_channel_stack_no_post_init(grpc_channel_stack*,
                                      grpc_channel_element*) {}
 
-namespace {
-
-grpc_core::NextPromiseFactory ClientNext(grpc_channel_element* elem) {
-  return [elem](grpc_core::CallArgs args) {
-    return elem->filter->make_call_promise(elem, std::move(args),
-                                           ClientNext(elem + 1));
-  };
-}
-
-grpc_core::NextPromiseFactory ServerNext(grpc_channel_element* elem) {
-  return [elem](grpc_core::CallArgs args) {
-    return elem->filter->make_call_promise(elem, std::move(args),
-                                           ServerNext(elem - 1));
-  };
-}
-
-}  // namespace
-
-grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-grpc_channel_stack::MakeClientCallPromise(grpc_core::CallArgs call_args) {
-  return ClientNext(grpc_channel_stack_element(this, 0))(std::move(call_args));
-}
-
-grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-grpc_channel_stack::MakeServerCallPromise(grpc_core::CallArgs call_args) {
-  return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
-      std::move(call_args));
-}
-
-void grpc_channel_stack::InitClientCallSpine(
-    grpc_core::CallSpineInterface* call) {
-  for (size_t i = 0; i < count; i++) {
-    auto* elem = grpc_channel_stack_element(this, i);
-    if (elem->filter->init_call == nullptr) {
-      grpc_core::Crash(
-          absl::StrCat("Filter '", elem->filter->name,
-                       "' does not support the call-v3 interface"));
-    }
-    elem->filter->init_call(elem, call);
-  }
-}
-
-void grpc_channel_stack::InitServerCallSpine(
-    grpc_core::CallSpineInterface* call) {
-  for (size_t i = 0; i < count; i++) {
-    auto* elem = grpc_channel_stack_element(this, count - 1 - i);
-    if (elem->filter->init_call == nullptr) {
-      grpc_core::Crash(
-          absl::StrCat("Filter '", elem->filter->name,
-                       "' does not support the call-v3 interface"));
-    }
-    elem->filter->init_call(elem, call);
-  }
-}
-
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {

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

@@ -59,10 +59,7 @@
 
 #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/channel/metrics.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
@@ -74,6 +71,8 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/metrics.h"
+#include "src/core/util/time_precise.h"
 
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
@@ -84,7 +83,6 @@ struct grpc_channel_element_args {
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
   const void* server_transport_data;
-  grpc_call_context_element* context;
   const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_core::Timestamp deadline;
@@ -107,24 +105,6 @@ struct grpc_channel_filter {
   // 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.
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
-      grpc_channel_element* elem, grpc_core::CallArgs call_args,
-      grpc_core::NextPromiseFactory next_promise_factory);
-  // Register interceptors into a call.
-  // If this is non-null it may be used in preference to make_call_promise.
-  // There is an on-going migration to move all filters to providing this, and
-  // then to drop start_transport_stream_op_batch.
-  void (*init_call)(grpc_channel_element* elem,
-                    grpc_core::CallSpineInterface* call_spine);
   // 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
@@ -230,18 +210,11 @@ struct grpc_channel_stack {
   // full C++-ification for now.
   void IncrementRefCount();
   void Unref();
+  void Unref(const grpc_core::DebugLocation& location, const char* reason);
   grpc_core::RefCountedPtr<grpc_channel_stack> Ref() {
     IncrementRefCount();
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
-
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-  MakeClientCallPromise(grpc_core::CallArgs call_args);
-  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
-  MakeServerCallPromise(grpc_core::CallArgs call_args);
-
-  void InitClientCallSpine(grpc_core::CallSpineInterface* call);
-  void InitServerCallSpine(grpc_core::CallSpineInterface* call);
 };
 
 // A call stack tracks a set of related filters for one call, and guarantees
@@ -346,6 +319,11 @@ inline void grpc_channel_stack::Unref() {
   GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
 }
 
+inline void grpc_channel_stack::Unref(const grpc_core::DebugLocation&,
+                                      const char* reason) {
+  GRPC_CHANNEL_STACK_UNREF(this, reason);
+}
+
 inline void grpc_call_stack::IncrementRefCount() {
   GRPC_CALL_STACK_REF(this, "smart_pointer");
 }
@@ -386,13 +364,11 @@ void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
 void grpc_channel_stack_no_post_init(grpc_channel_stack* stk,
                                      grpc_channel_element* elem);
 
-extern grpc_core::TraceFlag grpc_trace_channel;
-
-#define GRPC_CALL_LOG_OP(sev, elem, op)                \
-  do {                                                 \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_channel)) { \
-      grpc_call_log_op(sev, elem, op);                 \
-    }                                                  \
+#define GRPC_CALL_LOG_OP(sev, elem, op)     \
+  do {                                      \
+    if (GRPC_TRACE_FLAG_ENABLED(channel)) { \
+      grpc_call_log_op(sev, elem, op);      \
+    }                                       \
   } while (0)
 
 #endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_H

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

@@ -74,11 +74,6 @@ 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,

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

@@ -46,7 +46,6 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -54,153 +53,12 @@
 
 namespace grpc_core {
 
-namespace {
-
-const grpc_channel_filter* PromiseTracingFilterFor(
-    const grpc_channel_filter* filter) {
-  struct DerivedFilter : public grpc_channel_filter {
-    explicit DerivedFilter(const grpc_channel_filter* filter)
-        : grpc_channel_filter{
-              // start_transport_stream_op_batch:
-              grpc_call_next_op,
-              // make_call_promise:
-              [](grpc_channel_element* elem, CallArgs call_args,
-                 NextPromiseFactory next_promise_factory)
-                  -> ArenaPromise<ServerMetadataHandle> {
-                auto* source_filter =
-                    static_cast<const DerivedFilter*>(elem->filter)->filter;
-                gpr_log(
-                    GPR_DEBUG,
-                    "%s[%s] CreateCallPromise: client_initial_metadata=%s",
-                    GetContext<Activity>()->DebugTag().c_str(),
-                    source_filter->name,
-                    call_args.client_initial_metadata->DebugString().c_str());
-                return [source_filter, child = next_promise_factory(
-                                           std::move(call_args))]() mutable {
-                  gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: begin",
-                          GetContext<Activity>()->DebugTag().c_str(),
-                          source_filter->name);
-                  auto r = child();
-                  if (auto* p = r.value_if_ready()) {
-                    gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: done: %s",
-                            GetContext<Activity>()->DebugTag().c_str(),
-                            source_filter->name, (*p)->DebugString().c_str());
-                  } else {
-                    gpr_log(GPR_DEBUG, "%s[%s] PollCallPromise: <<pending>>",
-                            GetContext<Activity>()->DebugTag().c_str(),
-                            source_filter->name);
-                  }
-                  return r;
-                };
-              },
-              /* init_call: */
-              [](grpc_channel_element* elem, CallSpineInterface* call) {
-                auto* c = DownCast<PipeBasedCallSpine*>(call);
-                auto* source_filter =
-                    static_cast<const DerivedFilter*>(elem->filter)->filter;
-                c->client_initial_metadata().receiver.InterceptAndMap(
-                    [source_filter](ClientMetadataHandle md) {
-                      gpr_log(GPR_DEBUG, "%s[%s] OnClientInitialMetadata: %s",
-                              GetContext<Activity>()->DebugTag().c_str(),
-                              source_filter->name, md->DebugString().c_str());
-                      return md;
-                    });
-                c->client_to_server_messages().receiver.InterceptAndMap(
-                    [source_filter](MessageHandle msg) {
-                      gpr_log(GPR_DEBUG, "%s[%s] OnClientToServerMessage: %s",
-                              GetContext<Activity>()->DebugTag().c_str(),
-                              source_filter->name, msg->DebugString().c_str());
-                      return msg;
-                    });
-                c->server_initial_metadata().sender.InterceptAndMap(
-                    [source_filter](ServerMetadataHandle md) {
-                      gpr_log(GPR_DEBUG, "%s[%s] OnServerInitialMetadata: %s",
-                              GetContext<Activity>()->DebugTag().c_str(),
-                              source_filter->name, md->DebugString().c_str());
-                      return md;
-                    });
-                c->server_to_client_messages().sender.InterceptAndMap(
-                    [source_filter](MessageHandle msg) {
-                      gpr_log(GPR_DEBUG, "%s[%s] OnServerToClientMessage: %s",
-                              GetContext<Activity>()->DebugTag().c_str(),
-                              source_filter->name, msg->DebugString().c_str());
-                      return msg;
-                    });
-              },
-              grpc_channel_next_op,
-              /* sizeof_call_data: */ 0,
-              // init_call_elem:
-              [](grpc_call_element*, const grpc_call_element_args*) {
-                return absl::OkStatus();
-              },
-              grpc_call_stack_ignore_set_pollset_or_pollset_set,
-              // destroy_call_elem:
-              [](grpc_call_element*, const grpc_call_final_info*,
-                 grpc_closure*) {},
-              // sizeof_channel_data:
-              0,
-              // init_channel_elem:
-              [](grpc_channel_element*, grpc_channel_element_args*) {
-                return absl::OkStatus();
-              },
-              // post_init_channel_elem:
-              [](grpc_channel_stack*, grpc_channel_element*) {},
-              // destroy_channel_elem:
-              [](grpc_channel_element*) {}, grpc_channel_next_get_info,
-              // name:
-              nullptr},
-          filter(filter),
-          name_str(absl::StrCat(filter->name, ".trace")) {
-      this->name = name_str.c_str();
-    }
-    const grpc_channel_filter* const filter;
-    const std::string name_str;
-  };
-  struct Globals {
-    Mutex mu;
-    absl::flat_hash_map<const grpc_channel_filter*,
-                        std::unique_ptr<DerivedFilter>>
-        map ABSL_GUARDED_BY(mu);
-  };
-  auto* globals = NoDestructSingleton<Globals>::Get();
-  MutexLock lock(&globals->mu);
-  auto it = globals->map.find(filter);
-  if (it != globals->map.end()) return it->second.get();
-  return globals->map.emplace(filter, std::make_unique<DerivedFilter>(filter))
-      .first->second.get();
-}
-
-}  // namespace
-
-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() {
   std::vector<const grpc_channel_filter*> stack;
-  const bool is_promising = IsPromising();
-  const bool is_client =
-      grpc_channel_stack_type_is_client(channel_stack_type());
-  const bool client_promise_tracing =
-      is_client && is_promising && grpc_call_trace.enabled();
-  const bool server_promise_tracing =
-      !is_client && is_promising && grpc_call_trace.enabled();
 
   for (const auto* filter : this->stack()) {
-    if (client_promise_tracing) {
-      stack.push_back(PromiseTracingFilterFor(filter));
-    }
     stack.push_back(filter);
-    if (server_promise_tracing) {
-      stack.push_back(PromiseTracingFilterFor(filter));
-    }
-  }
-  if (server_promise_tracing) {
-    stack.pop_back();  // connected_channel must be last => can't be traced
   }
 
   // calculate the size of the channel stack

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

@@ -34,8 +34,6 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
  public:
   using ChannelStackBuilder::ChannelStackBuilder;
 
-  bool IsPromising() const override;
-
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,