metrics: Stabilize active_task_count

This stabilizes active_task_count. I also updated the metrics
integration test to split unstable/vs. stable metrics so that we
correctly test stable metrics in all cases.

Refs: tokio-rs#6546

tokio/src/runtime/metrics/runtime.rs

@@ -47,6 +47,25 @@ impl RuntimeMetrics {
         self.handle.inner.num_workers()
     }
 
+    /// Returns the number of active tasks in the runtime.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tokio::runtime::Handle;
+    ///
+    /// #[tokio::main]
+    /// async fn main() {
+    ///    let metrics = Handle::current().metrics();
+    ///
+    ///     let n = metrics.active_tasks_count();
+    ///     println!("Runtime has {} active tasks", n);
+    /// }
+    /// ```
+    pub fn active_tasks_count(&self) -> usize {
+        self.handle.inner.active_tasks_count()
+    }
+
     cfg_unstable_metrics! {
 
         /// Returns the number of additional threads spawned by the runtime.
@@ -75,25 +94,6 @@ impl RuntimeMetrics {
             self.handle.inner.num_blocking_threads()
         }
 
-        /// Returns the number of active tasks in the runtime.
-        ///
-        /// # Examples
-        ///
-        /// ```
-        /// use tokio::runtime::Handle;
-        ///
-        /// #[tokio::main]
-        /// async fn main() {
-        ///    let metrics = Handle::current().metrics();
-        ///
-        ///     let n = metrics.active_tasks_count();
-        ///     println!("Runtime has {} active tasks", n);
-        /// }
-        /// ```
-        pub fn active_tasks_count(&self) -> usize {
-            self.handle.inner.active_tasks_count()
-        }
-
         /// Returns the number of idle threads, which have spawned by the runtime
         /// for `spawn_blocking` calls.
         ///

tokio/src/runtime/scheduler/current_thread/mod.rs

@@ -500,6 +500,10 @@ impl Handle {
     pub(crate) fn reset_woken(&self) -> bool {
         self.shared.woken.swap(false, AcqRel)
     }
+
+    pub(crate) fn active_tasks_count(&self) -> usize {
+        self.shared.owned.active_tasks_count()
+    }
 }
 
 cfg_unstable_metrics! {
@@ -533,9 +537,6 @@ cfg_unstable_metrics! {
             self.blocking_spawner.queue_depth()
         }
 
-        pub(crate) fn active_tasks_count(&self) -> usize {
-            self.shared.owned.active_tasks_count()
-        }
     }
 }
 

tokio/src/runtime/scheduler/mod.rs

@@ -173,6 +173,10 @@ cfg_rt! {
                 Handle::MultiThreadAlt(handle) => handle.num_workers(),
             }
         }
+
+        pub(crate) fn active_tasks_count(&self) -> usize {
+            match_flavor!(self, Handle(handle) => handle.active_tasks_count())
+        }
     }
 
     cfg_unstable_metrics! {
@@ -187,9 +191,6 @@ cfg_rt! {
                 match_flavor!(self, Handle(handle) => handle.num_idle_blocking_threads())
             }
 
-            pub(crate) fn active_tasks_count(&self) -> usize {
-                match_flavor!(self, Handle(handle) => handle.active_tasks_count())
-            }
 
             pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics {
                 match_flavor!(self, Handle(handle) => handle.scheduler_metrics())

tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs

@@ -9,6 +9,10 @@ impl Handle {
         self.shared.worker_metrics.len()
     }
 
+    pub(crate) fn active_tasks_count(&self) -> usize {
+        self.shared.owned.active_tasks_count()
+    }
+
     cfg_unstable_metrics! {
         pub(crate) fn num_blocking_threads(&self) -> usize {
             // workers are currently spawned using spawn_blocking
@@ -21,9 +25,6 @@ impl Handle {
             self.blocking_spawner.num_idle_threads()
         }
 
-        pub(crate) fn active_tasks_count(&self) -> usize {
-            self.shared.owned.active_tasks_count()
-        }
 
         pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics {
             &self.shared.scheduler_metrics