Improve introspection for background_schedule_pool{,_log}

src/interpreter/clickhouse.rs

@@ -981,6 +981,76 @@ impl ClickHouse {
             .await;
     }
 
+    pub async fn get_background_schedule_pool_query_ids(
+        &self,
+        log_name: Option<String>,
+        database: String,
+        table: String,
+        start: RelativeDateTime,
+        end: RelativeDateTime,
+    ) -> Result<Vec<String>> {
+        let dbtable = self.get_table_name("system", "background_schedule_pool_log");
+
+        let start_sql = start
+            .to_sql_datetime_64()
+            .ok_or_else(|| Error::msg("Invalid start"))?;
+        let end_sql = end
+            .to_sql_datetime_64()
+            .ok_or_else(|| Error::msg("Invalid end"))?;
+
+        let query = if let Some(ref log_name) = log_name {
+            format!(
+                r#"
+                WITH {start} AS start_, {end} AS end_
+                SELECT DISTINCT query_id
+                FROM {dbtable}
+                WHERE
+                    event_date BETWEEN toDate(start_) AND toDate(end_) AND
+                    event_time BETWEEN toDateTime(start_) AND toDateTime(end_) AND
+                    log_name = '{log_name}' AND
+                    database = '{database}' AND
+                    table = '{table}'
+                LIMIT 1000
+                "#,
+                start = start_sql,
+                end = end_sql,
+                dbtable = dbtable,
+                log_name = log_name.replace('\'', "''"),
+                database = database.replace('\'', "''"),
+                table = table.replace('\'', "''"),
+            )
+        } else {
+            format!(
+                r#"
+                WITH {start} AS start_, {end} AS end_
+                SELECT DISTINCT query_id
+                FROM {dbtable}
+                WHERE
+                    event_date BETWEEN toDate(start_) AND toDate(end_) AND
+                    event_time BETWEEN toDateTime(start_) AND toDateTime(end_) AND
+                    database = '{database}' AND
+                    table = '{table}'
+                LIMIT 1000
+                "#,
+                start = start_sql,
+                end = end_sql,
+                dbtable = dbtable,
+                database = database.replace('\'', "''"),
+                table = table.replace('\'', "''"),
+            )
+        };
+
+        let columns = self.execute(&query).await?;
+        let mut query_ids = Vec::new();
+        for i in 0..columns.row_count() {
+            if let Ok(query_id) = columns.get::<String, _>(i, "query_id") {
+                query_ids.push(query_id);
+            }
+        }
+
+        Ok(query_ids)
+    }
+
     pub async fn execute(&self, query: &str) -> Result<Columns> {
         return Ok(self
             .pool

src/interpreter/clickhouse_quirks.rs

@@ -9,10 +9,11 @@ pub enum ClickHouseAvailableQuirks {
     SystemReplicasUUID = 8,
     QueryLogPeakThreadsUsage = 16,
     ProcessesPeakThreadsUsage = 32,
+    SystemBackgroundSchedulePool = 64,
 }
 
 // List of quirks (that requires workaround) or new features.
-const QUIRKS: [(&str, ClickHouseAvailableQuirks); 7] = [
+const QUIRKS: [(&str, ClickHouseAvailableQuirks); 8] = [
     // https://github.com/ClickHouse/ClickHouse/pull/46047
     //
     // NOTE: I use here 22.13 because I have such version in production, which is more or less the
@@ -40,6 +41,11 @@ const QUIRKS: [(&str, ClickHouseAvailableQuirks); 7] = [
         ">=25.11",
         ClickHouseAvailableQuirks::ProcessesPeakThreadsUsage,
     ),
+    // peak_threads_usage is available in system.processes since 25.11
+    (
+        ">=25.12",
+        ClickHouseAvailableQuirks::SystemBackgroundSchedulePool,
+    ),
 ];
 
 pub struct ClickHouseQuirks {

src/interpreter/options.rs

@@ -128,6 +128,8 @@ pub enum ChDigViews {
     Loggers,
     /// Show background schedule pool tasks (system.background_schedule_pool)
     BackgroundSchedulePool,
+    /// Show background schedule pool logs (system.background_schedule_pool_log)
+    BackgroundSchedulePoolLog,
     /// Spawn client inside chdig
     Client,
 }

src/interpreter/worker.rs

@@ -61,7 +61,13 @@ pub enum Event {
     // (view_name, query)
     SQLQuery(&'static str, String),
     // (log_name, database, table, start, end)
-    BackgroundSchedulePoolLogs(String, String, String, RelativeDateTime, RelativeDateTime),
+    BackgroundSchedulePoolLogs(
+        Option<String>,
+        String,
+        String,
+        RelativeDateTime,
+        RelativeDateTime,
+    ),
 }
 
 impl Event {
@@ -551,44 +557,44 @@ async fn process_event(context: ContextArc, event: Event, need_clear: &mut bool)
                 .map_err(|_| anyhow!("Cannot send message to UI"))?;
         }
         Event::BackgroundSchedulePoolLogs(log_name, database, table, start, end) => {
-            let dbtable = clickhouse.get_table_name("system", "background_schedule_pool_log");
-            let query = format!(
-                "SELECT DISTINCT query_id FROM {} WHERE log_name = '{}' AND database = '{}' AND table = '{}'",
-                dbtable,
-                log_name.replace('\'', "''"),
-                database.replace('\'', "''"),
-                table.replace('\'', "''"),
-            );
-
-            let columns = clickhouse.execute(&query).await?;
-            let mut query_ids = Vec::new();
-            for i in 0..columns.row_count() {
-                if let Ok(query_id) = columns.get::<String, _>(i, "query_id") {
-                    query_ids.push(query_id);
-                }
-            }
+            let query_ids = clickhouse
+                .get_background_schedule_pool_query_ids(
+                    log_name.clone(),
+                    database.clone(),
+                    table.clone(),
+                    start.clone(),
+                    end.clone(),
+                )
+                .await?;
 
             if query_ids.is_empty() {
-                return Err(anyhow!(
-                    "No entries for {} jobs (database: {}, table: {}, start: {}, end: {})",
-                    log_name,
-                    database,
-                    table,
-                    start,
-                    end
-                ));
+                let error_msg = if let Some(log_name) = log_name {
+                    format!(
+                        "No entries for {} jobs (database: {}, table: {}, start: {}, end: {})",
+                        log_name, database, table, start, end
+                    )
+                } else {
+                    format!(
+                        "No entries for {}.{} (start: {}, end: {})",
+                        database, table, start, end
+                    )
+                };
+                return Err(anyhow!(error_msg));
             }
 
+            let title = if let Some(ref log_name) = log_name {
+                format!("Logs for task: {}", log_name)
+            } else {
+                format!("Logs for tasks of {}.{}", database, table)
+            };
+
             cb_sink
                 .send(Box::new(move |siv: &mut cursive::Cursive| {
                     use cursive::view::Resizable;
                     let context = siv.user_data::<ContextArc>().unwrap().clone();
                     siv.add_layer(views::Dialog::around(
                         views::LinearLayout::vertical()
-                            .child(
-                                views::TextView::new(format!("Logs for task: {}", log_name))
-                                    .center(),
-                            )
+                            .child(views::TextView::new(title).center())
                             .child(views::DummyView.fixed_height(1))
                             .child(views::NamedView::new(
                                 "background_schedule_pool_logs",

src/view/navigation.rs

@@ -303,6 +303,7 @@ impl Navigation for Cursive {
         c.register_provider(Arc::new(ReplicasViewProvider));
         c.register_provider(Arc::new(TablesViewProvider));
         c.register_provider(Arc::new(BackgroundSchedulePoolViewProvider));
+        c.register_provider(Arc::new(BackgroundSchedulePoolLogViewProvider));
         c.register_provider(Arc::new(BackupsViewProvider));
         c.register_provider(Arc::new(DictionariesViewProvider));
         c.register_provider(Arc::new(ServerLogsViewProvider));

src/view/providers/background_schedule_pool.rs

@@ -1,9 +1,12 @@
 use crate::{
+    actions::ActionDescription,
     interpreter::{ContextArc, WorkerEvent, options::ChDigViews},
+    utils::fuzzy_actions,
     view::{self, navigation::Navigation, provider::ViewProvider},
 };
 use cursive::{
     Cursive,
+    event::Event,
     view::{Nameable, Resizable},
     views::Dialog,
 };
@@ -13,7 +16,7 @@ pub struct BackgroundSchedulePoolViewProvider;
 
 impl ViewProvider for BackgroundSchedulePoolViewProvider {
     fn name(&self) -> &'static str {
-        "Background jobs"
+        "Background Tasks"
     }
 
     fn view_type(&self) -> ChDigViews {
@@ -69,27 +72,52 @@ impl ViewProvider for BackgroundSchedulePoolViewProvider {
         )
         .unwrap_or_else(|_| panic!("Cannot get background_schedule_pool"));
 
-        let background_schedule_pool_logs_callback =
+        let background_schedule_pool_action_callback =
             move |siv: &mut Cursive, columns: Vec<&'static str>, row: view::QueryResultRow| {
-                show_logs_for_background_schedule_pool_task(siv, columns, row);
+                show_background_schedule_pool_actions(siv, columns, row);
             };
         view.get_inner_mut()
-            .set_on_submit(background_schedule_pool_logs_callback);
+            .set_on_submit(background_schedule_pool_action_callback);
 
         let view = view.with_name("background_schedule_pool").full_screen();
         siv.set_main_view(Dialog::around(view).title("Background Schedule Pool"));
     }
 }
 
-fn show_logs_for_background_schedule_pool_task(
+fn show_background_schedule_pool_actions(
     siv: &mut Cursive,
     columns: Vec<&'static str>,
     row: view::QueryResultRow,
 ) {
-    let row = row.0;
+    let actions = vec![
+        ActionDescription {
+            text: "Show tasks logs",
+            event: Event::Unknown(vec![]),
+        },
+        ActionDescription {
+            text: "Show tasks",
+            event: Event::Unknown(vec![]),
+        },
+    ];
+
+    let columns_clone = columns.clone();
+    let row_clone = row.clone();
+
+    fuzzy_actions(siv, actions, move |siv, selected| match selected.as_str() {
+        "Show tasks logs" => {
+            show_tasks_logs(siv, columns_clone.clone(), row_clone.clone());
+        }
+        "Show tasks" => {
+            show_tasks_summary(siv, columns_clone.clone(), row_clone.clone());
+        }
+        _ => {}
+    });
+}
 
+fn show_tasks_logs(siv: &mut Cursive, columns: Vec<&'static str>, row: view::QueryResultRow) {
+    let row_data = row.0;
     let mut map = HashMap::<String, String>::new();
-    columns.iter().zip(row.iter()).for_each(|(c, r)| {
+    columns.iter().zip(row_data.iter()).for_each(|(c, r)| {
         let value = r.to_string();
         map.insert(c.to_string(), value);
     });
@@ -110,11 +138,30 @@ fn show_logs_for_background_schedule_pool_task(
     context.lock().unwrap().worker.send(
         true,
         WorkerEvent::BackgroundSchedulePoolLogs(
-            log_name,
+            Some(log_name),
             database,
             table,
             view_options.start,
             view_options.end,
         ),
     );
 }
+
+fn show_tasks_summary(siv: &mut Cursive, columns: Vec<&'static str>, row: view::QueryResultRow) {
+    let row_data = row.0;
+    let mut map = HashMap::<String, String>::new();
+    columns.iter().zip(row_data.iter()).for_each(|(c, r)| {
+        let value = r.to_string();
+        map.insert(c.to_string(), value);
+    });
+
+    let log_name = map.get("log_name").map(|s| s.to_owned());
+    let database = map.get("database").map(|s| s.to_owned());
+    let table = map.get("table").map(|s| s.to_owned());
+
+    let context = siv.user_data::<ContextArc>().unwrap().clone();
+
+    super::background_schedule_pool_log::show_background_schedule_pool_log_dialog(
+        siv, context, log_name, database, table,
+    );
+}