feat(console): surface dropped events if there are any

tokio-console/src/main.rs

@@ -126,6 +126,25 @@ async fn main() -> color_eyre::Result<()> {
                     .0
                     .push(Span::styled(" PAUSED", view.styles.fg(Color::Red)));
             }
+            let dropped_async_ops_state = state.async_ops_state().dropped_events();
+            let dropped_tasks_state = state.tasks_state().dropped_events();
+            let dropped_resources_state = state.resources_state().dropped_events();
+            if (dropped_async_ops_state + dropped_tasks_state + dropped_resources_state) > 0 {
+                let mut dropped_texts = vec![];
+                if dropped_async_ops_state > 0 {
+                    dropped_texts.push(format!("{} async_ops", dropped_async_ops_state))
+                }
+                if dropped_tasks_state > 0 {
+                    dropped_texts.push(format!("{} tasks", dropped_tasks_state))
+                }
+                if dropped_resources_state > 0 {
+                    dropped_texts.push(format!("{} resources", dropped_resources_state))
+                }
+                header_text.0.push(Span::styled(
+                    format!(" dropped: {}", dropped_texts.join(", ")),
+                    view.styles.fg(Color::Red),
+                ));
+            }
             let header = Paragraph::new(header_text).wrap(Wrap { trim: true });
             let view_controls = Paragraph::new(Spans::from(vec![
                 Span::raw("views: "),

tokio-console/src/state/async_ops.rs

@@ -18,6 +18,7 @@ pub(crate) struct AsyncOpsState {
     async_ops: HashMap<u64, Rc<RefCell<AsyncOp>>>,
     ids: Ids,
     new_async_ops: Vec<AsyncOpRef>,
+    dropped_events: u64,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -201,6 +202,8 @@ impl AsyncOpsState {
                 }
             }
         }
+
+        self.dropped_events += update.dropped_events;
     }
 
     pub(crate) fn retain_active(&mut self, now: SystemTime, retain_for: Duration) {
@@ -217,6 +220,10 @@ impl AsyncOpsState {
                 .unwrap_or(true)
         })
     }
+
+    pub(crate) fn dropped_events(&self) -> u64 {
+        self.dropped_events
+    }
 }
 
 impl AsyncOp {

tokio-console/src/state/mod.rs

@@ -200,6 +200,10 @@ impl State {
         &mut self.tasks_state
     }
 
+    pub(crate) fn resources_state(&mut self) -> &ResourcesState {
+        &self.resources_state
+    }
+
     pub(crate) fn resources_state_mut(&mut self) -> &mut ResourcesState {
         &mut self.resources_state
     }

tokio-console/src/state/resources.rs

@@ -16,6 +16,7 @@ pub(crate) struct ResourcesState {
     resources: HashMap<u64, Rc<RefCell<Resource>>>,
     pub(crate) ids: Ids,
     new_resources: Vec<ResourceRef>,
+    dropped_events: u64,
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
@@ -225,6 +226,8 @@ impl ResourcesState {
             Some((num, resource))
         });
 
+        self.dropped_events += update.dropped_events;
+
         self.resources.extend(new_resources);
 
         for (span_id, stats) in stats_update {
@@ -252,6 +255,10 @@ impl ResourcesState {
                 .unwrap_or(true)
         })
     }
+
+    pub(crate) fn dropped_events(&self) -> u64 {
+        self.dropped_events
+    }
 }
 
 impl Resource {

tokio-console/src/state/tasks.rs

@@ -22,6 +22,7 @@ pub(crate) struct TasksState {
     pub(crate) ids: Ids,
     new_tasks: Vec<TaskRef>,
     pub(crate) linters: Vec<Linter<Task>>,
+    dropped_events: u64,
 }
 
 #[derive(Debug, Default)]
@@ -197,6 +198,8 @@ impl TasksState {
                 task.lint(linters);
             }
         }
+
+        self.dropped_events += update.dropped_events;
     }
 
     pub(crate) fn retain_active(&mut self, now: SystemTime, retain_for: Duration) {
@@ -220,6 +223,10 @@ impl TasksState {
     pub(crate) fn task(&self, id: u64) -> Option<TaskRef> {
         self.tasks.get(&id).map(Rc::downgrade)
     }
+
+    pub(crate) fn dropped_events(&self) -> u64 {
+        self.dropped_events
+    }
 }
 
 impl Details {