console: bold field names

console-api/src/common.rs

@@ -62,31 +62,6 @@ impl<'a> From<&'a std::panic::Location<'a>> for Location {
     }
 }
 
-impl fmt::Display for field::Value {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            field::Value::BoolVal(v) => fmt::Display::fmt(v, f)?,
-            field::Value::StrVal(v) => fmt::Display::fmt(v, f)?,
-            field::Value::U64Val(v) => fmt::Display::fmt(v, f)?,
-            field::Value::DebugVal(v) => fmt::Display::fmt(v, f)?,
-            field::Value::I64Val(v) => fmt::Display::fmt(v, f)?,
-        }
-
-        Ok(())
-    }
-}
-
-impl fmt::Display for Field {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let name_val = (self.name.as_ref(), self.value.as_ref());
-        if let (Some(field::Name::StrName(name)), Some(val)) = name_val {
-            write!(f, "{}={}", name, val)?;
-        }
-
-        Ok(())
-    }
-}
-
 impl fmt::Display for Location {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match (self.module_path.as_ref(), self.file.as_ref()) {

console/src/tasks.rs

@@ -4,19 +4,20 @@ use std::{
     cell::RefCell,
     collections::HashMap,
     convert::TryFrom,
-    fmt::Write,
+    fmt,
     rc::{Rc, Weak},
     time::{Duration, SystemTime},
 };
 use tui::{
     layout,
-    style::{self, Style},
-    text,
+    style::{self, Modifier, Style},
+    text::{self, Span, Spans},
     widgets::{Block, Cell, Row, Table, TableState},
 };
 #[derive(Debug)]
 pub(crate) struct State {
     tasks: HashMap<u64, Rc<RefCell<Task>>>,
+    metas: HashMap<u64, Metadata>,
     sorted_tasks: Vec<Weak<RefCell<Task>>>,
     sort_by: SortBy,
     table_state: TableState,
@@ -39,12 +40,18 @@ enum SortBy {
 pub(crate) struct Task {
     id: u64,
     id_hex: String,
-    fields: String,
+    fields: Vec<Field>,
     kind: &'static str,
     stats: Stats,
     completed_for: usize,
 }
 
+#[derive(Debug)]
+pub(crate) struct Metadata {
+    field_names: Vec<String>,
+    //TODO: add more metadata as needed
+}
+
 #[derive(Debug)]
 struct Stats {
     polls: u64,
@@ -54,6 +61,21 @@ struct Stats {
     total: Option<Duration>,
 }
 
+#[derive(Debug)]
+pub(crate) struct Field {
+    pub(crate) name: String,
+    pub(crate) value: FieldValue,
+}
+
+#[derive(Debug)]
+pub(crate) enum FieldValue {
+    Bool(bool),
+    Str(String),
+    U64(u64),
+    I64(i64),
+    Debug(String),
+}
+
 impl State {
     // How many updates to retain completed tasks for
     const RETAIN_COMPLETED_FOR: usize = 6;
@@ -114,8 +136,23 @@ impl State {
         if let Some(now) = update.now {
             self.last_updated_at = Some(now.into());
         }
+
+        if let Some(new_metada) = update.new_metadata {
+            let metas: HashMap<_, Metadata> = new_metada
+                .metadata
+                .into_iter()
+                .map(|meta| {
+                    let id = meta.id.expect("no id").id;
+                    let metadata = meta.metadata.expect("no metadata");
+                    (id, metadata.into())
+                })
+                .collect();
+            self.metas.extend(metas);
+        }
+
         let mut stats_update = update.stats_update;
         let sorted = &mut self.sorted_tasks;
+        let metas = &mut self.metas;
         let new_tasks = update.new_tasks.into_iter().filter_map(|task| {
             if task.id.is_none() {
                 tracing::warn!(?task, "skipping task with no id");
@@ -127,12 +164,23 @@ impl State {
             let fields = task
                 .fields
                 .iter()
-                .fold(String::new(), |mut res, f| {
-                    write!(&mut res, "{} ", f).unwrap();
-                    res
+                .filter_map(|f| {
+                    let field_name = f.name.as_ref().expect("no name");
+                    let name = match field_name {
+                        proto::field::Name::StrName(n) => Some(n.clone()),
+                        proto::field::Name::NameIdx(idx) => {
+                            let meta_id = f.metadata_id.as_ref().expect("no id");
+                            metas
+                                .get(&meta_id.id)
+                                .and_then(|meta| meta.field_names.get(*idx as usize))
+                                .cloned()
+                        }
+                    };
+                    let value = f.value.as_ref().expect("no value").clone().into();
+                    name.map(|name| Field { name, value })
                 })
-                .trim_end()
-                .into();
+                .collect();
+
             let id = task.id?.id;
             let stats = stats_update.remove(&id)?.into();
             let mut task = Task {
@@ -182,6 +230,19 @@ impl State {
         let rows = self.sorted_tasks.iter().filter_map(|task| {
             let task = task.upgrade()?;
             let task = task.borrow();
+
+            let fields = Spans::from(task.fields().iter().fold(Vec::default(), |mut acc, f| {
+                acc.extend(vec![
+                    Span::styled(
+                        f.name.clone(),
+                        Style::default().add_modifier(Modifier::BOLD),
+                    ),
+                    Span::from("="),
+                    Span::from(format!("{} ", f.value)),
+                ]);
+                acc
+            }));
+
             let mut row = Row::new(vec![
                 Cell::from(task.id_hex.to_string()),
                 // TODO(eliza): is there a way to write a `fmt::Debug` impl
@@ -206,7 +267,7 @@ impl State {
                     prec = DUR_PRECISION,
                 )),
                 Cell::from(format!("{:>width$}", task.stats.polls, width = POLLS_LEN)),
-                Cell::from(task.fields.to_string()),
+                Cell::from(fields),
             ]);
             if task.completed_for > 0 {
                 row = row.style(Style::default().add_modifier(style::Modifier::DIM));
@@ -330,6 +391,7 @@ impl Default for State {
     fn default() -> Self {
         Self {
             tasks: Default::default(),
+            metas: Default::default(),
             sorted_tasks: Default::default(),
             sort_by: Default::default(),
             selected_column: SortBy::default() as usize,
@@ -345,7 +407,7 @@ impl Task {
         &self.id_hex
     }
 
-    pub(crate) fn fields(&self) -> &str {
+    pub(crate) fn fields(&self) -> &Vec<Field> {
         &self.fields
     }
 
@@ -397,6 +459,26 @@ impl From<proto::tasks::Stats> for Stats {
     }
 }
 
+impl From<proto::Metadata> for Metadata {
+    fn from(pb: proto::Metadata) -> Self {
+        Self {
+            field_names: pb.field_names,
+        }
+    }
+}
+
+impl From<proto::field::Value> for FieldValue {
+    fn from(pb: proto::field::Value) -> Self {
+        match pb {
+            proto::field::Value::BoolVal(v) => Self::Bool(v),
+            proto::field::Value::StrVal(v) => Self::Str(v),
+            proto::field::Value::I64Val(v) => Self::I64(v),
+            proto::field::Value::U64Val(v) => Self::U64(v),
+            proto::field::Value::DebugVal(v) => Self::Debug(v),
+        }
+    }
+}
+
 impl Default for SortBy {
     fn default() -> Self {
         Self::Total
@@ -437,3 +519,17 @@ impl TryFrom<usize> for SortBy {
         }
     }
 }
+
+impl fmt::Display for FieldValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FieldValue::Bool(v) => fmt::Display::fmt(v, f)?,
+            FieldValue::Str(v) => fmt::Display::fmt(v, f)?,
+            FieldValue::U64(v) => fmt::Display::fmt(v, f)?,
+            FieldValue::Debug(v) => fmt::Display::fmt(v, f)?,
+            FieldValue::I64(v) => fmt::Display::fmt(v, f)?,
+        }
+
+        Ok(())
+    }
+}

console/src/view/task.rs

@@ -1,5 +1,5 @@
 use crate::{input, tasks::Task};
-use std::{cell::RefCell, rc::Rc, time::SystemTime};
+use std::{cell::RefCell, fmt::Write, rc::Rc, time::SystemTime};
 use tui::{
     layout,
     style::{self, Style},
@@ -35,6 +35,16 @@ impl TaskView {
         let task = &*self.task.borrow();
         const DUR_PRECISION: usize = 4;
 
+        let fields: String = task
+            .fields()
+            .iter()
+            .fold(String::new(), |mut res, f| {
+                write!(&mut res, "{}={} ", f.name, f.value).unwrap();
+                res
+            })
+            .trim_end()
+            .into();
+
         let attrs = Spans::from(vec![
             Span::styled("ID: ", Style::default().add_modifier(style::Modifier::BOLD)),
             Span::raw(task.id_hex()),
@@ -43,7 +53,7 @@ impl TaskView {
                 "Fields: ",
                 Style::default().add_modifier(style::Modifier::BOLD),
             ),
-            Span::raw(task.fields()),
+            Span::raw(fields),
         ]);
 
         let metrics = Spans::from(vec![