grpc 1.62.0.pre1 → 1.63.0

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

@@ -26,19 +26,19 @@
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
 #include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/tcp_tracer.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -128,12 +128,16 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
   // as transparent retry attempts.)
   class CallAttemptTracer : public CallTracerInterface {
    public:
-    enum class OptionalLabelComponent : std::uint8_t {
-      kXdsServiceLabels = 0,
-      kSize = 1,  // keep last
+    // Note that not all of the optional label keys are exposed as public API.
+    enum class OptionalLabelKey : std::uint8_t {
+      kXdsServiceName,       // not public
+      kXdsServiceNamespace,  // not public
+      kLocality,
+      kSize  // should be last
     };
 
     ~CallAttemptTracer() override {}
+
     // TODO(yashykt): The following two methods `RecordReceivedTrailingMetadata`
     // and `RecordEnd` should be moved into CallTracerInterface.
     // If the call was cancelled before the recv_trailing_metadata op
@@ -146,10 +150,10 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
     // library is free to destroy the object.
     virtual void RecordEnd(const gpr_timespec& latency) = 0;
 
-    // Adds optional labels to be reported by the underlying tracer in a call.
-    virtual void AddOptionalLabels(
-        OptionalLabelComponent component,
-        std::shared_ptr<std::map<std::string, std::string>> labels) = 0;
+    // Sets an optional label on the per-attempt metrics recorded at the end of
+    // the attempt.
+    virtual void SetOptionalLabel(OptionalLabelKey key,
+                                  RefCountedStringValue value) = 0;
   };
 
   ~ClientCallTracer() override {}
@@ -207,8 +211,6 @@ class ServerCallTracerFactory {
   static absl::string_view ChannelArgName();
 };
 
-void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
-
 // Convenience functions to add call tracers to a call context. Allows setting
 // multiple call tracers to a single call. It is only valid to add client call
 // tracers before the client_channel filter sees the send_initial_metadata op.

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

@@ -129,6 +129,7 @@ grpc_error_handle grpc_channel_stack_init(
 
   stack->on_destroy.Init([]() {});
   stack->event_engine.Init(channel_args.GetObjectRef<EventEngine>());
+  stack->stats_plugin_group.Init();
 
   size_t call_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
@@ -188,6 +189,7 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   (*stack->on_destroy)();
   stack->on_destroy.Destroy();
   stack->event_engine.Destroy();
+  stack->stats_plugin_group.Destroy();
 }
 
 grpc_error_handle grpc_call_stack_init(
@@ -347,3 +349,10 @@ void grpc_channel_stack::InitServerCallSpine(
     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) {
+  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
+          grpc_transport_stream_op_batch_string(op, false).c_str());
+}

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

@@ -61,6 +61,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"
@@ -219,6 +220,10 @@ struct grpc_channel_stack {
     return event_engine->get();
   }
 
+  grpc_core::ManualConstructor<
+      grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>
+      stats_plugin_group;
+
   // 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

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

@@ -23,22 +23,162 @@
 #include <string.h>
 
 #include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.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/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
+#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"
+#include "src/core/lib/transport/transport.h"
 
 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* source_filter =
+                    static_cast<const DerivedFilter*>(elem->filter)->filter;
+                call->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;
+                    });
+                call->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;
+                    });
+                call->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;
+                    });
+                call->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;
+                    });
+                call->server_trailing_metadata().sender.InterceptAndMap(
+                    [source_filter](ServerMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerTrailingMetadata: %s",
+                              GetContext<Activity>()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+              },
+              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;

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

@@ -120,7 +120,7 @@ class BaseNode : public RefCounted<BaseNode> {
 //   - track calls_{started,succeeded,failed}
 //   - track last_call_started_timestamp
 //   - perform rendering of the above items
-class CallCountingHelper {
+class CallCountingHelper final {
  public:
   void RecordCallStarted();
   void RecordCallFailed();
@@ -139,7 +139,7 @@ class CallCountingHelper {
   std::atomic<gpr_cycle_counter> last_call_started_cycle_{0};
 };
 
-class PerCpuCallCountingHelper {
+class PerCpuCallCountingHelper final {
  public:
   void RecordCallStarted();
   void RecordCallFailed();
@@ -183,7 +183,7 @@ class PerCpuCallCountingHelper {
 };
 
 // Handles channelz bookkeeping for channels
-class ChannelNode : public BaseNode {
+class ChannelNode final : public BaseNode {
  public:
   ChannelNode(std::string target, size_t channel_tracer_max_nodes,
               bool is_internal_channel);
@@ -191,6 +191,9 @@ class ChannelNode : public BaseNode {
   static absl::string_view ChannelArgName() {
     return GRPC_ARG_CHANNELZ_CHANNEL_NODE;
   }
+  static int ChannelArgsCompare(const ChannelNode* a, const ChannelNode* b) {
+    return QsortCompare(a, b);
+  }
 
   // Returns the string description of the given connectivity state.
   static const char* GetChannelConnectivityStateChangeString(
@@ -244,7 +247,7 @@ class ChannelNode : public BaseNode {
 };
 
 // Handles channelz bookkeeping for servers
-class ServerNode : public BaseNode {
+class ServerNode final : public BaseNode {
  public:
   explicit ServerNode(size_t channel_tracer_max_nodes);
 
@@ -288,7 +291,7 @@ class ServerNode : public BaseNode {
 #define GRPC_ARG_CHANNELZ_SECURITY "grpc.internal.channelz_security"
 
 // Handles channelz bookkeeping for sockets
-class SocketNode : public BaseNode {
+class SocketNode final : public BaseNode {
  public:
   struct Security : public RefCounted<Security> {
     struct Tls {
@@ -364,7 +367,7 @@ class SocketNode : public BaseNode {
 };
 
 // Handles channelz bookkeeping for listen sockets
-class ListenSocketNode : public BaseNode {
+class ListenSocketNode final : public BaseNode {
  public:
   ListenSocketNode(std::string local_addr, std::string name);
   ~ListenSocketNode() override {}

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

@@ -36,7 +36,7 @@ namespace channelz {
 
 // singleton registry object to track all objects that are needed to support
 // channelz bookkeeping. All objects share globally distributed uuids.
-class ChannelzRegistry {
+class ChannelzRegistry final {
  public:
   static void Register(BaseNode* node) {
     return Default()->InternalRegister(node);

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

@@ -465,7 +465,7 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(Transport* transport,
   // Start a promise to receive server initial metadata and then forward it up
   // through the receiving pipe.
   auto server_initial_metadata =
-      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+      GetContext<Arena>()->MakePooled<ServerMetadata>();
   party->Spawn(
       "recv_initial_metadata",
       TrySeq(GetContext<BatchBuilder>()->ReceiveServerInitialMetadata(
@@ -503,15 +503,14 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(Transport* transport,
   // If this fails, we massage the error into metadata that we can report
   // upwards.
   auto server_trailing_metadata =
-      GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+      GetContext<Arena>()->MakePooled<ServerMetadata>();
   auto recv_trailing_metadata =
       Map(GetContext<BatchBuilder>()->ReceiveServerTrailingMetadata(
               stream->batch_target()),
           [](absl::StatusOr<ServerMetadataHandle> status) mutable {
             if (!status.ok()) {
               auto server_trailing_metadata =
-                  GetContext<Arena>()->MakePooled<ServerMetadata>(
-                      GetContext<Arena>());
+                  GetContext<Arena>()->MakePooled<ServerMetadata>();
               grpc_status_code status_code = GRPC_STATUS_UNKNOWN;
               std::string message;
               grpc_error_get_status(status.status(), Timestamp::InfFuture(),
@@ -787,8 +786,7 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
               trailing_metadata = std::move(*status);
             } else {
               trailing_metadata =
-                  GetContext<Arena>()->MakePooled<ClientMetadata>(
-                      GetContext<Arena>());
+                  GetContext<Arena>()->MakePooled<ClientMetadata>();
               grpc_status_code status_code = GRPC_STATUS_UNKNOWN;
               std::string message;
               grpc_error_get_status(status.status(), Timestamp::InfFuture(),
@@ -898,8 +896,7 @@ ArenaPromise<ServerMetadataHandle> MakeClientTransportCallPromise(
                  md->Set(GrpcStatusFromWire(), true);
                  return md;
                }
-               auto m = GetContext<Arena>()->MakePooled<ServerMetadata>(
-                   GetContext<Arena>());
+               auto m = GetContext<Arena>()->MakePooled<ServerMetadata>();
                m->Set(GrpcStatusMetadata(), GRPC_STATUS_CANCELLED);
                m->Set(GrpcCallWasCancelled(), true);
                return m;