1 files changed, 18 insertions, 35 deletions

diff --git a/cli/tools/test/mod.rs b/cli/tools/test/mod.rs
index 4ec90050e..0f10188bc 100644
--- a/cli/tools/test/mod.rs
+++ b/cli/tools/test/mod.rs
@@ -728,6 +728,7 @@ async fn run_tests_for_worker_inner(
   let mut filter = RuntimeActivityStatsFilter::default();
   filter = filter.with_resources();
   filter = filter.with_ops();
+  filter = filter.with_timers();
   filter = filter.omit_op(op_id_host_recv_ctrl as _);
   filter = filter.omit_op(op_id_host_recv_message as _);
 
@@ -825,37 +826,6 @@ async fn run_tests_for_worker_inner(
   Ok(())
 }
 
-/// Removes timer resources and op_sleep_interval calls. When an interval is started before a test
-/// and resolves during a test, there's a false alarm.
-fn preprocess_timer_activity(activities: &mut Vec<RuntimeActivity>) {
-  // TODO(mmastrac): Once we get to the new timer implementation, all of this
-  // code can go away and be replaced by a proper timer sanitizer.
-  let mut timer_resource_leaked = false;
-
-  // First, search for any timer resources which will indicate that we have an interval leak
-  activities.retain(|activity| {
-    if let RuntimeActivity::Resource(.., name) = activity {
-      if name == "timer" {
-        timer_resource_leaked = true;
-        return false;
-      }
-    }
-    true
-  });
-
-  // If we've leaked a timer resource, we un-mute op_sleep_interval calls. Otherwise, we remove
-  // them.
-  if !timer_resource_leaked {
-    activities.retain(|activity| {
-      if let RuntimeActivity::AsyncOp(.., op) = activity {
-        *op != "op_sleep_interval"
-      } else {
-        true
-      }
-    })
-  }
-}
-
 async fn wait_for_activity_to_stabilize(
   worker: &mut MainWorker,
   stats: &RuntimeActivityStatsFactory,
@@ -867,8 +837,6 @@ async fn wait_for_activity_to_stabilize(
   // First, check to see if there's any diff at all. If not, just continue.
   let after = stats.clone().capture(filter);
   let mut diff = RuntimeActivityStats::diff(&before, &after);
-  preprocess_timer_activity(&mut diff.appeared);
-  preprocess_timer_activity(&mut diff.disappeared);
   if diff.is_empty() {
     // No activity, so we return early
     return Ok(None);
@@ -884,8 +852,6 @@ async fn wait_for_activity_to_stabilize(
 
     let after = stats.clone().capture(filter);
     diff = RuntimeActivityStats::diff(&before, &after);
-    preprocess_timer_activity(&mut diff.appeared);
-    preprocess_timer_activity(&mut diff.disappeared);
     if diff.is_empty() {
       return Ok(None);
     }
@@ -908,6 +874,23 @@ async fn wait_for_activity_to_stabilize(
       .retain(|activity| !matches!(activity, RuntimeActivity::Resource(..)));
   }
 
+  // Since we don't have an option to disable timer sanitization, we use sanitize_ops == false &&
+  // sanitize_resources == false to disable those.
+  if !sanitize_ops && !sanitize_resources {
+    diff.appeared.retain(|activity| {
+      !matches!(
+        activity,
+        RuntimeActivity::Timer(..) | RuntimeActivity::Interval(..)
+      )
+    });
+    diff.disappeared.retain(|activity| {
+      !matches!(
+        activity,
+        RuntimeActivity::Timer(..) | RuntimeActivity::Interval(..)
+      )
+    });
+  }
+
   Ok(if diff.is_empty() { None } else { Some(diff) })
 }