chore: migrate to new deno_core and metrics

Cargo.toml

@@ -40,7 +40,7 @@ repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
 deno_ast = { version = "0.31.2", features = ["transpiling"] }
-deno_core = { version = "0.224.0" }
+deno_core = { version = "0.225.0" }
 
 deno_runtime = { version = "0.130.0", path = "./runtime" }
 napi_sym = { version = "0.52.0", path = "./cli/napi/sym" }

cli/args/flags.rs

@@ -398,6 +398,7 @@ pub struct Flags {
   pub config_flag: ConfigFlag,
   pub node_modules_dir: Option<bool>,
   pub vendor: Option<bool>,
+  pub enable_op_summary_metrics: bool,
   pub enable_testing_features: bool,
   pub ext: Option<String>,
   pub ignore: Vec<PathBuf>,

cli/args/mod.rs

@@ -1137,6 +1137,14 @@ impl CliOptions {
     }
   }
 
+  pub fn enable_op_summary_metrics(&self) -> bool {
+    self.flags.enable_op_summary_metrics
+      || matches!(
+        self.flags.subcommand,
+        DenoSubcommand::Test(_) | DenoSubcommand::Repl(_)
+      )
+  }
+
   pub fn enable_testing_features(&self) -> bool {
     self.flags.enable_testing_features
   }

cli/factory.rs

@@ -670,6 +670,7 @@ impl CliFactory {
       argv: self.options.argv().clone(),
       log_level: self.options.log_level().unwrap_or(log::Level::Info).into(),
       coverage_dir: self.options.coverage_dir(),
+      enable_op_summary_metrics: self.options.enable_op_summary_metrics(),
       enable_testing_features: self.options.enable_testing_features(),
       has_node_modules_dir: self.options.has_node_modules_dir(),
       hmr: self.options.has_hmr(),

cli/main.rs

@@ -368,8 +368,7 @@ pub fn main() {
       // Using same default as VSCode:
       // https://github.com/microsoft/vscode/blob/48d4ba271686e8072fc6674137415bc80d936bc7/extensions/typescript-language-features/src/configuration/configuration.ts#L213-L214
       DenoSubcommand::Lsp => vec!["--max-old-space-size=3072".to_string()],
-      // TODO(bartlomieju): upstream this to `deno_core` crate
-      _ => vec!["--harmony-array-from-async".to_string()],
+      _ => vec![],
     };
     init_v8_flags(&default_v8_flags, &flags.v8_flags, get_v8_flags_from_env());
     deno_core::JsRuntime::init_platform(None);

cli/ops/testing.rs

@@ -14,16 +14,17 @@ use deno_core::error::AnyError;
 use deno_core::op2;
 use deno_core::v8;
 use deno_core::ModuleSpecifier;
-use deno_core::OpMetrics;
+use deno_core::OpMetricsSummary;
+use deno_core::OpMetricsSummaryTracker;
 use deno_core::OpState;
 use deno_runtime::deno_fetch::reqwest;
 use deno_runtime::permissions::create_child_permissions;
 use deno_runtime::permissions::ChildPermissionsArg;
 use deno_runtime::permissions::PermissionsContainer;
 use serde::Serialize;
-use std::cell::Ref;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::rc::Rc;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use uuid::Uuid;
@@ -243,38 +244,28 @@ fn op_test_event_step_result_failed(
 struct TestOpSanitizers(HashMap<u32, TestOpSanitizerState>);
 
 enum TestOpSanitizerState {
-  Collecting { metrics: Vec<OpMetrics> },
+  Collecting { metrics: Vec<OpMetricsSummary> },
   Finished { report: Vec<TestOpSanitizerReport> },
 }
 
 fn try_collect_metrics(
-  state: &OpState,
+  metrics: &OpMetricsSummaryTracker,
   force: bool,
   op_id_host_recv_msg: usize,
   op_id_host_recv_ctrl: usize,
-) -> Result<Ref<Vec<OpMetrics>>, bool> {
-  let metrics = state.tracker.per_op();
-  for op_metric in &*metrics {
-    let has_pending_ops = op_metric.ops_dispatched_async
-      + op_metric.ops_dispatched_async_unref
-      > op_metric.ops_completed_async + op_metric.ops_completed_async_unref;
-    if has_pending_ops && !force {
-      let host_recv_msg = metrics
-        .get(op_id_host_recv_msg)
-        .map(|op_metric| {
-          op_metric.ops_dispatched_async + op_metric.ops_dispatched_async_unref
-            > op_metric.ops_completed_async
-              + op_metric.ops_completed_async_unref
-        })
-        .unwrap_or(false);
-      let host_recv_ctrl = metrics
-        .get(op_id_host_recv_ctrl)
-        .map(|op_metric| {
-          op_metric.ops_dispatched_async + op_metric.ops_dispatched_async_unref
-            > op_metric.ops_completed_async
-              + op_metric.ops_completed_async_unref
-        })
-        .unwrap_or(false);
+) -> Result<std::cell::Ref<Vec<OpMetricsSummary>>, bool> {
+  let metrics = metrics.per_op();
+  let host_recv_msg = metrics
+    .get(op_id_host_recv_msg)
+    .map(OpMetricsSummary::has_outstanding_ops)
+    .unwrap_or(false);
+  let host_recv_ctrl = metrics
+    .get(op_id_host_recv_ctrl)
+    .map(OpMetricsSummary::has_outstanding_ops)
+    .unwrap_or(false);
+
+  for op_metric in metrics.iter() {
+    if op_metric.has_outstanding_ops() && !force {
       return Err(host_recv_msg || host_recv_ctrl);
     }
   }
@@ -294,23 +285,23 @@ fn op_test_op_sanitizer_collect(
   #[smi] op_id_host_recv_msg: usize,
   #[smi] op_id_host_recv_ctrl: usize,
 ) -> Result<u8, AnyError> {
-  let metrics = {
-    let metrics = match try_collect_metrics(
-      state,
-      force,
-      op_id_host_recv_msg,
-      op_id_host_recv_ctrl,
-    ) {
-      Ok(metrics) => metrics,
-      Err(false) => {
-        return Ok(1);
-      }
-      Err(true) => {
-        return Ok(2);
-      }
-    };
-    metrics.clone()
-  };
+  let metrics = state.borrow::<Rc<OpMetricsSummaryTracker>>();
+  let metrics = match try_collect_metrics(
+    metrics,
+    force,
+    op_id_host_recv_msg,
+    op_id_host_recv_ctrl,
+  ) {
+    Ok(metrics) => metrics,
+    Err(false) => {
+      return Ok(1);
+    }
+    Err(true) => {
+      return Ok(2);
+    }
+  }
+  .clone();
+
   let op_sanitizers = state.borrow_mut::<TestOpSanitizers>();
   match op_sanitizers.0.entry(id) {
     Entry::Vacant(entry) => {
@@ -348,11 +339,12 @@ fn op_test_op_sanitizer_finish(
 ) -> Result<u8, AnyError> {
   // Drop `fetch` connection pool at the end of a test
   state.try_take::<reqwest::Client>();
+  let metrics = state.borrow::<Rc<OpMetricsSummaryTracker>>();
 
   // Generate a report of pending ops
   let report = {
     let after_metrics = match try_collect_metrics(
-      state,
+      metrics,
       force,
       op_id_host_recv_msg,
       op_id_host_recv_ctrl,
@@ -380,14 +372,10 @@ fn op_test_op_sanitizer_finish(
     for (id, (before, after)) in
       before_metrics.iter().zip(after_metrics.iter()).enumerate()
     {
-      let async_pending_before = before.ops_dispatched_async
-        + before.ops_dispatched_async_unref
-        - before.ops_completed_async
-        - before.ops_completed_async_unref;
-      let async_pending_after = after.ops_dispatched_async
-        + after.ops_dispatched_async_unref
-        - after.ops_completed_async
-        - after.ops_completed_async_unref;
+      let async_pending_before =
+        before.ops_dispatched_async - before.ops_completed_async;
+      let async_pending_after =
+        after.ops_dispatched_async - after.ops_completed_async;
       let diff = async_pending_after as i64 - async_pending_before as i64;
       if diff != 0 {
         report.push(TestOpSanitizerReport { id, diff });

cli/standalone/mod.rs

@@ -453,6 +453,7 @@ pub async fn run(
       argv: metadata.argv,
       log_level: WorkerLogLevel::Info,
       coverage_dir: None,
+      enable_op_summary_metrics: false,
       enable_testing_features: false,
       has_node_modules_dir,
       hmr: false,

cli/tests/integration/js_unit_tests.rs

@@ -53,7 +53,6 @@ util::unit_test_factory!(
     link_test,
     make_temp_test,
     message_channel_test,
-    metrics_test,
     mkdir_test,
     navigator_test,
     net_test,

cli/tests/integration/run_tests.rs

@@ -3425,11 +3425,6 @@ itest!(unstable_ffi_19 {
   exit_code: 70,
 });
 
-itest!(future_check2 {
-  args: "run --check run/future_check.ts",
-  output: "run/future_check2.out",
-});
-
 itest!(event_listener_error {
   args: "run --quiet run/event_listener_error.ts",
   output: "run/event_listener_error.ts.out",

cli/tests/unit/timers_test.ts

@@ -412,19 +412,6 @@ Deno.test(function clearTimeoutAndClearIntervalNotBeEquals() {
   assertNotEquals(clearTimeout, clearInterval);
 });
 
-Deno.test(async function timerMaxCpuBug() {
-  // There was a bug where clearing a timeout would cause Deno to use 100% CPU.
-  clearTimeout(setTimeout(() => {}, 1000));
-  // We can check this by counting how many ops have triggered in the interim.
-  // Certainly less than 10 ops should have been dispatched in next 100 ms.
-  const { ops: pre } = Deno.metrics();
-  await delay(100);
-  const { ops: post } = Deno.metrics();
-  const before = pre.op_sleep.opsDispatched;
-  const after = post.op_sleep.opsDispatched;
-  assert(after - before < 10);
-});
-
 Deno.test(async function timerOrdering() {
   const array: number[] = [];
   const donePromise = deferred();

cli/tsc/mod.rs

@@ -948,7 +948,7 @@ mod tests {
         .context("Unable to get CWD")
         .unwrap(),
     );
-    let mut op_state = OpState::new(1, None);
+    let mut op_state = OpState::new(None);
     op_state.put(state);
     op_state
   }