[core][stats-die/04] kill STATS in the common component

Signed-off-by: Cuong Nguyen <can@anyscale.com>

Author: can-anyscale

src/ray/common/BUILD.bazel

@@ -281,6 +281,7 @@ ray_cc_library(
     ],
     deps = [
         ":event_stats",
+        ":metrics",
         ":ray_config",
         "//src/ray/util:array",
         "//src/ray/util:function_traits",
@@ -311,6 +312,7 @@ ray_cc_library(
         "event_stats.h",
     ],
     deps = [
+        ":metrics",
         ":ray_config",
         "//src/ray/stats:stats_metric",
         "//src/ray/util:time",

src/ray/common/asio/instrumented_io_context.cc

@@ -20,7 +20,6 @@
 #include "ray/common/asio/asio_chaos.h"
 #include "ray/common/asio/asio_util.h"
 #include "ray/stats/metric.h"
-#include "ray/stats/metric_defs.h"
 
 namespace {
 
@@ -35,7 +34,7 @@ void LagProbeLoop(instrumented_io_context &io_context,
         auto end = std::chrono::steady_clock::now();
         auto duration =
             std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
-        ray::stats::STATS_io_context_event_loop_lag_ms.Record(
+        io_context.io_context_event_loop_lag_ms_gauge_metric.Record(
             duration.count(),
             {
                 {"Name", context_name.value_or(GetThreadName())},

src/ray/common/asio/instrumented_io_context.h

@@ -19,6 +19,7 @@
 #include <string>
 
 #include "ray/common/event_stats.h"
+#include "ray/common/metrics.h"
 #include "ray/common/ray_config.h"
 #include "ray/util/logging.h"
 
@@ -58,6 +59,9 @@ class instrumented_io_context : public boost::asio::io_context {
 
   EventTracker &stats() const { return *event_stats_; };
 
+  ray::stats::Gauge io_context_event_loop_lag_ms_gauge_metric{
+      ray::GetIoContextEventLoopLagMsGaugeMetric()};
+
  private:
   /// The event stats tracker to use to record asio handler stats to.
   std::shared_ptr<EventTracker> event_stats_;

src/ray/common/event_stats.cc

@@ -21,7 +21,6 @@
 #include <utility>
 
 #include "ray/stats/metric.h"
-#include "ray/stats/metric_defs.h"
 #include "ray/util/time.h"
 
 namespace {
@@ -64,20 +63,22 @@ std::shared_ptr<StatsHandle> EventTracker::RecordStart(
     ++stats->stats.cum_count;
     curr_count = ++stats->stats.curr_count;
   }
+  auto handle =
+      std::make_shared<StatsHandle>(std::move(name),
+                                    ray::current_time_ns() + expected_queueing_delay_ns,
+                                    std::move(stats),
+                                    global_stats_,
+                                    emit_metrics,
+                                    event_context_name);
 
   if (emit_metrics) {
-    ray::stats::STATS_operation_count.Record(1, event_context_name.value_or(name));
-    ray::stats::STATS_operation_active_count.Record(curr_count,
-                                                    event_context_name.value_or(name));
+    handle->operation_count_metric_.Record(1,
+                                           {{"Name", event_context_name.value_or(name)}});
+    handle->operation_active_gauge_metric_.Record(
+        curr_count, {{"Name", event_context_name.value_or(name)}});
   }
 
-  return std::make_shared<StatsHandle>(
-      std::move(name),
-      ray::current_time_ns() + expected_queueing_delay_ns,
-      std::move(stats),
-      global_stats_,
-      emit_metrics,
-      event_context_name);
+  return handle;
 }
 
 void EventTracker::RecordEnd(std::shared_ptr<StatsHandle> handle) {
@@ -89,10 +90,11 @@ void EventTracker::RecordEnd(std::shared_ptr<StatsHandle> handle) {
 
   if (handle->emit_stats) {
     // Update event-specific stats.
-    ray::stats::STATS_operation_run_time_ms.Record(
-        execution_time_ns / 1000000, handle->context_name.value_or(handle->event_name));
-    ray::stats::STATS_operation_active_count.Record(
-        curr_count, handle->context_name.value_or(handle->event_name));
+    handle->operation_run_time_ms_histogram_metric_.Record(
+        execution_time_ns / 1000000,
+        {{"Name", handle->context_name.value_or(handle->event_name)}});
+    handle->operation_active_gauge_metric_.Record(
+        curr_count, {{"Name", handle->context_name.value_or(handle->event_name)}});
   }
 
   handle->end_or_execution_recorded = true;
@@ -135,13 +137,15 @@ void EventTracker::RecordExecution(const std::function<void()> &fn,
 
   if (handle->emit_stats) {
     // Update event-specific stats.
-    ray::stats::STATS_operation_run_time_ms.Record(
-        execution_time_ns / 1000000, handle->context_name.value_or(handle->event_name));
-    ray::stats::STATS_operation_active_count.Record(
-        curr_count, handle->context_name.value_or(handle->event_name));
+    handle->operation_run_time_ms_histogram_metric_.Record(
+        execution_time_ns / 1000000,
+        {{"Name", handle->context_name.value_or(handle->event_name)}});
+    handle->operation_active_gauge_metric_.Record(
+        curr_count, {{"Name", handle->context_name.value_or(handle->event_name)}});
     // Update global stats.
-    ray::stats::STATS_operation_queue_time_ms.Record(
-        queue_time_ns / 1000000, handle->context_name.value_or(handle->event_name));
+    handle->operation_queue_time_ms_histogram_metric_.Record(
+        queue_time_ns / 1000000,
+        {{"Name", handle->context_name.value_or(handle->event_name)}});
   }
 
   {

src/ray/common/event_stats.h

@@ -18,6 +18,7 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/synchronization/mutex.h"
+#include "ray/common/metrics.h"
 #include "ray/common/ray_config.h"
 #include "ray/util/logging.h"
 
@@ -77,6 +78,14 @@ struct StatsHandle {
   const bool emit_stats;
   const std::optional<std::string> context_name;
 
+  ray::stats::Count operation_count_metric_{ray::GetOperationCountCounterMetric()};
+  ray::stats::Gauge operation_active_gauge_metric_{
+      ray::GetOperationActiveCountGaugeMetric()};
+  ray::stats::Histogram operation_run_time_ms_histogram_metric_{
+      ray::GetOperationRunTimeMsHistogramMetric()};
+  ray::stats::Histogram operation_queue_time_ms_histogram_metric_{
+      ray::GetOperationQueueTimeMsHistogramMetric()};
+
   StatsHandle(std::string event_name_,
               const int64_t start_time_,
               std::shared_ptr<GuardedEventStats> handler_stats_,

src/ray/common/metrics.h

@@ -86,4 +86,51 @@ inline ray::stats::Histogram GetSchedulerPlacementTimeSHistogramMetric() {
   };
 }
 
+inline ray::stats::Gauge GetIoContextEventLoopLagMsGaugeMetric() {
+  return ray::stats::Gauge{
+      /*name=*/"io_context_event_loop_lag_ms",
+      /*description=*/"The latency of a task from post to execution",
+      /*unit=*/"ms",
+      /*tag_keys=*/{"Name"},
+  };
+}
+
+inline ray::stats::Count GetOperationCountCounterMetric() {
+  return ray::stats::Count{
+      /*name=*/"operation_count",
+      /*description=*/"operation count",
+      /*unit=*/"",
+      /*tag_keys=*/{"Name"},
+  };
+}
+
+inline ray::stats::Histogram GetOperationRunTimeMsHistogramMetric() {
+  return ray::stats::Histogram{
+      /*name=*/"operation_run_time_ms",
+      /*description=*/"operation execution time",
+      /*unit=*/"ms",
+      /*boundaries=*/{1, 10, 100, 1000, 10000},
+      /*tag_keys=*/{"Name"},
+  };
+}
+
+inline ray::stats::Histogram GetOperationQueueTimeMsHistogramMetric() {
+  return ray::stats::Histogram{
+      /*name=*/"operation_queue_time_ms",
+      /*description=*/"operation queuing time",
+      /*unit=*/"ms",
+      /*boundaries=*/{1, 10, 100, 1000, 10000},
+      /*tag_keys=*/{"Name"},
+  };
+}
+
+inline ray::stats::Gauge GetOperationActiveCountGaugeMetric() {
+  return ray::stats::Gauge{
+      /*name=*/"operation_active_count",
+      /*description=*/"active operation number",
+      /*unit=*/"",
+      /*tag_keys=*/{"Name"},
+  };
+}
+
 }  // namespace ray

src/ray/stats/metric_defs.cc

@@ -74,27 +74,6 @@ DEFINE_stats(
 /// ===================== INTERNAL SYSTEM METRICS =================================
 /// ===============================================================================
 
-DEFINE_stats(io_context_event_loop_lag_ms,
-             "Latency of a task from post to execution",
-             ("Name"),  // Name of the instrumented_io_context.
-             (),
-             ray::stats::GAUGE);
-
-/// Event stats
-DEFINE_stats(operation_count, "operation count", ("Name"), (), ray::stats::COUNT);
-DEFINE_stats(operation_run_time_ms,
-             "operation execution time",
-             ("Name"),
-             ({1, 10, 100, 1000, 10000}),
-             ray::stats::HISTOGRAM);
-DEFINE_stats(operation_queue_time_ms,
-             "operation queuing time",
-             ("Name"),
-             ({1, 10, 100, 1000, 10000}),
-             ray::stats::HISTOGRAM);
-DEFINE_stats(
-    operation_active_count, "active operation number", ("Name"), (), ray::stats::GAUGE);
-
 /// Scheduler
 DEFINE_stats(
     scheduler_tasks,

src/ray/stats/metric_defs.h

@@ -42,15 +42,6 @@ namespace stats {
 /// ray_[component]_[metrics_name]_total (e.g., ray_pull_manager_total)
 ///
 
-/// ASIO stats
-DECLARE_stats(io_context_event_loop_lag_ms);
-
-/// Event stats
-DECLARE_stats(operation_count);
-DECLARE_stats(operation_run_time_ms);
-DECLARE_stats(operation_queue_time_ms);
-DECLARE_stats(operation_active_count);
-
 /// Scheduler
 DECLARE_stats(scheduler_failed_worker_startup_total);
 DECLARE_stats(scheduler_tasks);