server: introduce ServerMetricRecorder API and move per-call reporting from a C++ interceptor to a C-core filter

BUILD

@@ -1972,6 +1972,7 @@ grpc_cc_library(
     ],
     visibility = ["@grpc:public"],
     deps = [
+        "gpr",
         "grpc_trace",
         "//src/core:grpc_backend_metric_data",
     ],
@@ -1999,11 +2000,13 @@ grpc_cc_library(
         "gpr",
         "grpc++",
         "grpc_base",
+        "grpcpp_server_metric_recorder",
         "protobuf_duration_upb",
         "ref_counted_ptr",
         "xds_orca_service_upb",
         "xds_orca_upb",
         "//src/core:default_event_engine",
+        "//src/core:grpc_backend_metric_data",
         "//src/core:ref_counted",
         "//src/core:time",
     ],

include/grpcpp/ext/call_metric_recorder.h

@@ -28,63 +28,49 @@
 #include <grpcpp/impl/sync.h>
 #include <grpcpp/support/slice.h>
 
-namespace grpc_core {
-class Arena;
-struct BackendMetricData;
-}  // namespace grpc_core
-
 namespace grpc {
-class ServerBuilder;
-
 namespace experimental {
 
-// Registers the per-rpc orca load reporter into the \a ServerBuilder.
-// Once this is done, the server will automatically send the load metrics
-// after each RPC as they were reported. In order to report load metrics,
-// call the \a ServerContext::ExperimentalGetCallMetricRecorder() method to
-// retrieve the recorder for the current call.
-void EnableCallMetricRecording(ServerBuilder*);
-
 /// Records call metrics for the purpose of load balancing.
 /// During an RPC, call \a ServerContext::ExperimentalGetCallMetricRecorder()
 /// method to retrive the recorder for the current call.
 class CallMetricRecorder {
  public:
   virtual ~CallMetricRecorder() = default;
 
-  // Records a call metric measurement for CPU utilization.
-  // Multiple calls to this method will override the stored value.
-  // Values outside of the valid range [0, 1] are ignored.
+  /// Records a call metric measurement for CPU utilization.
+  /// Multiple calls to this method will override the stored value.
+  /// Values outside of the valid range [0, 1] are ignored.
   virtual CallMetricRecorder& RecordCpuUtilizationMetric(double value) = 0;
 
-  // Records a call metric measurement for memory utilization.
-  // Multiple calls to this method will override the stored value.
-  // Values outside of the valid range [0, 1] are ignored.
+  /// Records a call metric measurement for memory utilization.
+  /// Multiple calls to this method will override the stored value.
+  /// Values outside of the valid range [0, 1] are ignored.
   virtual CallMetricRecorder& RecordMemoryUtilizationMetric(double value) = 0;
 
-  // Records a call metric measurement for queries per second.
-  // Multiple calls to this method will override the stored value.
-  // Values outside of the valid range [0, infy) are ignored.
+  /// Records a call metric measurement for queries per second.
+  /// Multiple calls to this method will override the stored value.
+  /// Values outside of the valid range [0, infy) are ignored.
   virtual CallMetricRecorder& RecordQpsMetric(double value) = 0;
 
-  // Records a call metric measurement for utilization.
-  // Multiple calls to this method with the same name will
-  // override the corresponding stored value. The lifetime of the
-  // name string needs to be longer than the lifetime of the RPC
-  // itself, since it's going to be sent as trailers after the RPC
-  // finishes. It is assumed the strings are common names that
-  // are global constants.
-  // Values outside of the valid range [0, 1] are ignored.
+  /// Records a call metric measurement for utilization.
+  /// Multiple calls to this method with the same name will
+  /// override the corresponding stored value. The lifetime of the
+  /// name string needs to be longer than the lifetime of the RPC
+  /// itself, since it's going to be sent as trailers after the RPC
+  /// finishes. It is assumed the strings are common names that
+  /// are global constants.
+  /// Values outside of the valid range [0, 1] are ignored.
   virtual CallMetricRecorder& RecordUtilizationMetric(string_ref name,
                                                       double value) = 0;
 
-  // Records a call metric measurement for request cost.
-  // Multiple calls to this method with the same name will
-  // override the corresponding stored value. The lifetime of the
-  // name string needs to be longer than the lifetime of the RPC
-  // itself, since it's going to be sent as trailers after the RPC
-  // finishes. It is assumed the strings are common names that
-  // are global constants.
+  /// Records a call metric measurement for request cost.
+  /// Multiple calls to this method with the same name will
+  /// override the corresponding stored value. The lifetime of the
+  /// name string needs to be longer than the lifetime of the RPC
+  /// itself, since it's going to be sent as trailers after the RPC
+  /// finishes. It is assumed the strings are common names that
+  /// are global constants.
   virtual CallMetricRecorder& RecordRequestCostMetric(string_ref name,
                                                       double value) = 0;
 };

include/grpcpp/ext/orca_service.h

@@ -23,6 +23,7 @@
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
 
+#include <grpcpp/ext/server_metric_recorder.h>
 #include <grpcpp/impl/service_type.h>
 #include <grpcpp/impl/sync.h>
 #include <grpcpp/server_builder.h>
@@ -48,38 +49,16 @@ class OrcaService : public Service {
     }
   };
 
-  explicit OrcaService(Options options);
-
-  // Sets or removes the CPU utilization value to be reported to clients.
-  void SetCpuUtilization(double cpu_utilization);
-  void DeleteCpuUtilization();
-
-  // Sets of removes the memory utilization value to be reported to clients.
-  void SetMemoryUtilization(double memory_utilization);
-  void DeleteMemoryUtilization();
-
-  // Sets of removes the QPS value to be reported to clients.
-  void SetQps(double qps);
-  void DeleteQps();
-
-  // Sets or removed named utilization values to be reported to clients.
-  void SetNamedUtilization(std::string name, double utilization);
-  void DeleteNamedUtilization(const std::string& name);
-  void SetAllNamedUtilization(std::map<std::string, double> named_utilization);
+  OrcaService(const ServerMetricRecorder& server_metric_recorder,
+              Options options);
 
  private:
   class Reactor;
 
-  Slice GetOrCreateSerializedResponse();
+  Slice CreateSerializedResponse();
 
+  const ServerMetricRecorder& server_metric_recorder_;
   const absl::Duration min_report_duration_;
-
-  grpc::internal::Mutex mu_;
-  double cpu_utilization_ ABSL_GUARDED_BY(&mu_) = -1;
-  double memory_utilization_ ABSL_GUARDED_BY(&mu_) = -1;
-  double qps_ ABSL_GUARDED_BY(&mu_) = -1;
-  std::map<std::string, double> named_utilization_ ABSL_GUARDED_BY(&mu_);
-  absl::optional<Slice> response_slice_ ABSL_GUARDED_BY(&mu_);
 };
 
 }  // namespace experimental

include/grpcpp/ext/server_metric_recorder.h

@@ -27,54 +27,53 @@
 #include "absl/types/optional.h"
 
 namespace grpc_core {
-class Arena;
 struct BackendMetricData;
 }  // namespace grpc_core
 
 namespace grpc {
 class BackendMetricState;
-class ServerBuilder;
 
 namespace experimental {
 
-/// Records server wide metrics for the purpose of load balancing.
+/// Records server wide metrics to be reported to the client.
 /// Server implementation creates an instance and reports server metrics to it,
 /// and then passes it to
 /// ServerBuilder::experimental_type::EnableCallMetricRecording or
 /// experimental::OrcaService that read metrics to include in the report.
 class ServerMetricRecorder {
  public:
-  // Records the server CPU utilization in the range [0, 1].
-  // Values outside of the valid range are rejected.
-  // Overrides the stored value when called again with a valid value.
+  /// Records the server CPU utilization in the range [0, 1].
+  /// Values outside of the valid range are rejected.
+  /// Overrides the stored value when called again with a valid value.
   void SetCpuUtilization(double value);
-  // Records the server memory utilization in the range [0, 1].
-  // Values outside of the valid range are rejected.
-  // Overrides the stored value when called again with a valid value.
-  void SetMemUtilization(double value);
-  // Records number of queries per second to the server in the range [0, infy).
-  // Values outside of the valid range are rejected.
-  // Overrides the stored value when called again with a valid value.
+  /// Records the server memory utilization in the range [0, 1].
+  /// Values outside of the valid range are rejected.
+  /// Overrides the stored value when called again with a valid value.
+  void SetMemoryUtilization(double value);
+  /// Records number of queries per second to the server in the range [0, infy).
+  /// Values outside of the valid range are rejected.
+  /// Overrides the stored value when called again with a valid value.
   void SetQps(double value);
 
-  // Clears the server CPU utilization if recorded.
+  /// Clears the server CPU utilization if recorded.
   void ClearCpuUtilization();
-  // Clears the server memory utilization if recorded.
-  void ClearMemUtilization();
-  // Clears number of queries per second to the server if recorded.
+  /// Clears the server memory utilization if recorded.
+  void ClearMemoryUtilization();
+  /// Clears number of queries per second to the server if recorded.
   void ClearQps();
 
  private:
+  // To access GetMetrics().
+  friend class grpc::BackendMetricState;
+  friend class OrcaService;
+
   // Only populates fields in `data` that this has recorded metrics.
-  void GetMetrics(grpc_core::BackendMetricData* data);
+  grpc_core::BackendMetricData GetMetrics() const;
 
   // Defaults to -1.0 (unset).
   std::atomic<double> cpu_utilization_{-1.0};
   std::atomic<double> mem_utilization_{-1.0};
   std::atomic<double> qps_{-1.0};
-
-  // To access GetMetrics().
-  friend class grpc::BackendMetricState;
 };
 
 }  // namespace experimental

include/grpcpp/server_builder.h

@@ -59,7 +59,6 @@ class ExternalConnectionAcceptorImpl;
 class CallbackGenericService;
 
 namespace experimental {
-class OrcaServerInterceptorFactory;
 // EXPERIMENTAL API:
 // Interface for a grpc server to build transports with connections created out
 // of band.
@@ -283,13 +282,13 @@ class ServerBuilder {
         std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
             provider);
 
-    // Enables per-call load reporting. The server will automatically send the
-    // load metrics after each RPC. The caller can report load metrics for the
-    // current call to what ServerContext::ExperimentalGetCallMetricRecorder()
-    // returns. The server merges metrics from the optional
-    // server_metric_recorder when provided where the call metric recorder take
-    // a higher precedence. The caller owns and must ensure the server metric
-    // recorder outlives the server.
+    /// Enables per-call load reporting. The server will automatically send the
+    /// load metrics after each RPC. The caller can report load metrics for the
+    /// current call to what ServerContext::ExperimentalGetCallMetricRecorder()
+    /// returns. The server merges metrics from the optional
+    /// server_metric_recorder when provided where the call metric recorder take
+    /// a higher precedence. The caller owns and must ensure the server metric
+    /// recorder outlives the server.
     void EnableCallMetricRecording(
         experimental::ServerMetricRecorder* server_metric_recorder = nullptr);
 
@@ -365,7 +364,6 @@ class ServerBuilder {
 
  private:
   friend class grpc::testing::ServerBuilderPluginTest;
-  friend class grpc::experimental::OrcaServerInterceptorFactory;
 
   struct SyncServerSettings {
     SyncServerSettings()

include/grpcpp/server_context.h

@@ -51,10 +51,6 @@ struct grpc_metadata;
 struct grpc_call;
 struct census_context;
 
-namespace grpc_core {
-struct BackendMetricData;
-}  // namespace grpc_core
-
 namespace grpc {
 template <class W, class R>
 class ServerAsyncReader;

src/core/BUILD

@@ -3605,15 +3605,11 @@ grpc_cc_library(
 grpc_cc_library(
     name = "grpc_backend_metric_data",
     hdrs = [
-        "ext/filters/backend_metrics/backend_metric_data.h",
+        "ext/filters/client_channel/lb_policy/backend_metric_data.h",
     ],
     external_deps = ["absl/strings"],
     language = "c++",
-    deps = [
-        "//:gpr",
-        "//:gpr_platform",
-        "//:grpc_trace",
-    ],
+    deps = [ "//:gpr_platform", ],
 )
 
 grpc_cc_library(

src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -6,7 +6,7 @@
 #include "upb/upb.hpp"
 #include "xds/data/orca/v3/orca_load_report.upb.h"
 
-#include "src/core/ext/filters/backend_metrics/backend_metric_data.h"
+#include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -92,4 +92,17 @@ ArenaPromise<ServerMetadataHandle> BackendMetricFilter::MakeCallPromise(
       }));
 }
 
+static bool maybe_prepend_grpc_backend_metric_filter(
+    grpc_core::ChannelStackBuilder* builder) {
+  if (builder->channel_args().Contains(GRPC_ARG_SERVER_CALL_METRIC_RECORDING)) {
+    builder->PrependFilter(&grpc_core::BackendMetricFilter::kFilter);
+  }
+  return true;
+}
+
+void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
+      GRPC_SERVER_CHANNEL, INT_MAX, maybe_prepend_grpc_backend_metric_filter);
+}
+
 }  // namespace grpc_core

src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -10,8 +10,8 @@
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
-#include "src/core/ext/filters/backend_metrics/backend_metric_data.h"
 #include "src/core/ext/filters/backend_metrics/backend_metric_provider.h"
+#include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/promise_based_filter.h"