[timeline] add commands for hiding/showing row types

Author: tstack

NEWS.md

@@ -153,6 +153,11 @@ Features:
   instance extending to the end of the log.  Partition
   rows span from their start time to the next partition
   (or end of log).
+* Added `:hide-in-timeline` and `:show-in-timeline`
+  commands to control which row types (logfile, thread,
+  opid, tag, partition) are visible in the timeline view.
+  The `:hide-in-timeline` command supports live preview,
+  highlighting rows that would be hidden in red.
 * The `timestamp-point-of-reference` log format property
   has been added to specify the related of the timestamp
   to the operation that the message refers to, either:

src/cmds.display.cc

@@ -30,6 +30,7 @@
 #include "base/intern_string.hh"
 #include "lnav.hh"
 #include "readline_context.hh"
+#include "timeline_source.hh"
 
 static Result<std::string, lnav::console::user_message>
 com_set_text_view_mode(exec_context& ec,
@@ -157,6 +158,67 @@ com_toggle_field(exec_context& ec,
     return Ok(retval);
 }
 
+static Result<std::string, lnav::console::user_message>
+com_timeline_row_type_visibility(exec_context& ec,
+                                 std::string cmdline,
+                                 std::vector<std::string>& args)
+{
+    std::string retval;
+
+    if (args.size() < 2) {
+        auto* tss = static_cast<timeline_source*>(
+            lnav_data.ld_views[LNV_TIMELINE].get_sub_source());
+        tss->gs_preview_hidden_row_types.clear();
+        lnav_data.ld_views[LNV_TIMELINE].set_needs_update();
+        return ec.make_error("Expecting a row type");
+    }
+
+    const auto hide = args[0] == "hide-in-timeline";
+    std::vector<std::string> found_types, unknown_types;
+
+    for (size_t lpc = 1; lpc < args.size(); lpc++) {
+        auto rt_opt = timeline_source::row_type_from_string(args[lpc]);
+        if (rt_opt) {
+            found_types.emplace_back(args[lpc]);
+        } else {
+            unknown_types.emplace_back(args[lpc]);
+        }
+    }
+
+    if (!unknown_types.empty()) {
+        return ec.make_error("unknown row type(s) -- {}",
+                             fmt::join(unknown_types, ", "));
+    }
+
+    auto* tss = static_cast<timeline_source*>(
+        lnav_data.ld_views[LNV_TIMELINE].get_sub_source());
+    if (ec.ec_dry_run) {
+        tss->gs_preview_hidden_row_types.clear();
+        if (hide) {
+            for (const auto& type_name : found_types) {
+                auto rt_opt = timeline_source::row_type_from_string(type_name);
+                tss->gs_preview_hidden_row_types.insert(rt_opt.value());
+            }
+        }
+        lnav_data.ld_views[LNV_TIMELINE].set_needs_update();
+        retval = "";
+    } else {
+        tss->gs_preview_hidden_row_types.clear();
+        for (const auto& type_name : found_types) {
+            auto rt_opt = timeline_source::row_type_from_string(type_name);
+            tss->set_row_type_visibility(rt_opt.value(), !hide);
+        }
+        tss->text_filters_changed();
+
+        auto visibility = hide ? "hiding" : "showing";
+        retval = fmt::format(FMT_STRING("info: {} row type(s) -- {}"),
+                             visibility,
+                             fmt::join(found_types, ", "));
+    }
+
+    return Ok(retval);
+}
+
 static readline_context::command_t DISPLAY_COMMANDS[] = {
     {
         "set-text-view-mode",
@@ -208,6 +270,46 @@ static readline_context::command_t DISPLAY_COMMANDS[] = {
             .with_opposites({"hide-fields"})
             .with_tags({"display"}),
     },
+    {
+        "hide-in-timeline",
+        com_timeline_row_type_visibility,
+
+        help_text(":hide-in-timeline")
+            .with_summary("Hide rows of the given type(s) in the timeline "
+                          "view")
+            .with_parameter(help_text("row-type", "The type of row to hide")
+                                .one_or_more()
+                                .with_enum_values({
+                                    "logfile"_frag,
+                                    "thread"_frag,
+                                    "opid"_frag,
+                                    "tag"_frag,
+                                    "partition"_frag,
+                                }))
+            .with_example({"To hide logfile and thread rows", "logfile thread"})
+            .with_opposites({"show-in-timeline"})
+            .with_tags({"display"}),
+    },
+    {
+        "show-in-timeline",
+        com_timeline_row_type_visibility,
+
+        help_text(":show-in-timeline")
+            .with_summary("Show rows of the given type(s) that were "
+                          "previously hidden in the timeline view")
+            .with_parameter(help_text("row-type", "The type of row to show")
+                                .one_or_more()
+                                .with_enum_values({
+                                    "logfile"_frag,
+                                    "thread"_frag,
+                                    "opid"_frag,
+                                    "tag"_frag,
+                                    "partition"_frag,
+                                }))
+            .with_example({"To show logfile and thread rows", "logfile thread"})
+            .with_opposites({"hide-in-timeline"})
+            .with_tags({"display"}),
+    },
 };
 
 void

src/internals/cmd-ref.rst

@@ -853,6 +853,29 @@
 ----
 
 
+.. _hide_in_timeline:
+
+:hide-in-timeline *row-type*
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  Hide rows of the given type(s) in the timeline view
+
+  **Parameters**
+    * **row-type** --- The type of row to hide
+
+  **Examples**
+    To hide logfile and thread rows:
+
+    .. code-block::  lnav
+
+      :hide-in-timeline logfile thread
+
+  **See Also**
+    :ref:`enable_word_wrap`, :ref:`hide_fields`, :ref:`set_text_view_mode`, :ref:`show_in_timeline`
+
+----
+
+
 .. _hide_lines_after:
 
 :hide-lines-after *date*
@@ -1513,6 +1536,29 @@
 ----
 
 
+.. _show_in_timeline:
+
+:show-in-timeline *row-type*
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  Show rows of the given type(s) that were previously hidden in the timeline view
+
+  **Parameters**
+    * **row-type** --- The type of row to show
+
+  **Examples**
+    To show logfile and thread rows:
+
+    .. code-block::  lnav
+
+      :show-in-timeline logfile thread
+
+  **See Also**
+    :ref:`enable_word_wrap`, :ref:`hide_fields`, :ref:`hide_in_timeline`, :ref:`set_text_view_mode`
+
+----
+
+
 .. _show_lines_before_and_after:
 
 :show-lines-before-and-after

src/session_data.cc

@@ -57,6 +57,7 @@
 #include "sql_util.hh"
 #include "sqlitepp.client.hh"
 #include "tailer/tailer.looper.hh"
+#include "timeline_source.hh"
 #include "vtab_module.hh"
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
@@ -1793,6 +1794,12 @@ reset_session()
 
     lnav_data.ld_db_row_source.reset_user_state();
 
+    auto* tss = static_cast<timeline_source*>(
+        lnav_data.ld_views[LNV_TIMELINE].get_sub_source());
+    if (tss != nullptr) {
+        tss->gs_hidden_row_types.clear();
+    }
+
     for (auto& tc : lnav_data.ld_views) {
         text_sub_source* tss = tc.get_sub_source();
 

src/timeline_source.cc

@@ -464,6 +464,62 @@ timeline_source::timeline_source(textview_curses& log_view,
     this->gs_preview_view.set_overlay_source(&this->gs_preview_overlay);
 }
 
+std::optional<timeline_source::row_type>
+timeline_source::row_type_from_string(const std::string& str)
+{
+    if (str == "logfile") {
+        return row_type::logfile;
+    }
+    if (str == "thread") {
+        return row_type::thread;
+    }
+    if (str == "opid") {
+        return row_type::opid;
+    }
+    if (str == "tag") {
+        return row_type::tag;
+    }
+    if (str == "partition") {
+        return row_type::partition;
+    }
+    return std::nullopt;
+}
+
+const char*
+timeline_source::row_type_to_string(row_type rt)
+{
+    switch (rt) {
+        case row_type::logfile:
+            return "logfile";
+        case row_type::thread:
+            return "thread";
+        case row_type::opid:
+            return "opid";
+        case row_type::tag:
+            return "tag";
+        case row_type::partition:
+            return "partition";
+    }
+    return "unknown";
+}
+
+void
+timeline_source::set_row_type_visibility(row_type rt, bool visible)
+{
+    if (visible) {
+        this->gs_hidden_row_types.erase(rt);
+    } else {
+        this->gs_hidden_row_types.insert(rt);
+    }
+}
+
+bool
+timeline_source::is_row_type_visible(row_type rt) const
+{
+    return this->gs_hidden_row_types.find(rt)
+        == this->gs_hidden_row_types.end();
+}
+
 bool
 timeline_source::list_input_handle_key(listview_curses& lv, const ncinput& ch)
 {
@@ -571,7 +627,7 @@ timeline_source::text_value_for_line(textview_curses& tc,
         auto duration
             = row.or_value.otr_range.tr_end - row.or_value.otr_range.tr_begin;
         auto duration_str = fmt::format(
-            FMT_STRING(" {: >13}"),
+            FMT_STRING("{: >13}"),
             humanize::time::duration::from_tv(to_timeval(duration))
                 .to_string());
 
@@ -601,6 +657,18 @@ timeline_source::text_value_for_line(textview_curses& tc,
                 icon = ui_icon_t::partition;
                 break;
         }
+        if (this->gs_preview_hidden_row_types.count(row.or_type) > 0) {
+            this->gs_rendered_line.append(
+                "-",
+                VC_STYLE.value(text_attrs{
+                    lnav::enums::to_underlying(text_attrs::style::blink),
+                    styling::color_unit::from_palette(
+                        lnav::enums::to_underlying(ansi_color::red)),
+                }));
+        } else {
+            this->gs_rendered_line.append(" ");
+        }
+
         this->gs_rendered_line
             .append(duration_str, VC_ROLE.value(role_t::VCR_OFFSET_TIME))
             .append("  ")
@@ -1007,6 +1075,11 @@ timeline_source::rebuild_indexes()
             full_desc += pair.second.or_description;
         }
 
+        if (!this->is_row_type_visible(row.or_type)) {
+            this->gs_filtered_count += 1;
+            continue;
+        }
+
         shared_buffer sb_opid;
         shared_buffer_ref sbr_opid;
         sbr_opid.share(
@@ -1379,6 +1452,25 @@ timeline_source::text_filters_changed()
     this->tss_view->redo_search();
 }
 
+void
+timeline_source::clear_preview()
+{
+    text_sub_source::clear_preview();
+    this->gs_preview_hidden_row_types.clear();
+}
+
+void
+timeline_source::add_commands_for_session(
+    const std::function<void(const std::string&)>& receiver)
+{
+    text_sub_source::add_commands_for_session(receiver);
+
+    for (const auto& rt : this->gs_hidden_row_types) {
+        receiver(fmt::format(FMT_STRING("hide-in-timeline {}"),
+                             row_type_to_string(rt)));
+    }
+}
+
 int
 timeline_source::get_filtered_count() const
 {

src/timeline_source.hh

@@ -34,6 +34,7 @@
 #include <functional>
 #include <memory>
 #include <optional>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -99,6 +100,9 @@ public:
     void text_selection_changed(textview_curses& tc) override;
 
     void text_filters_changed() override;
+    void clear_preview() override;
+    void add_commands_for_session(
+        const std::function<void(const std::string&)>& receiver) override;
     int get_filtered_count() const override;
     int get_filtered_count_for(size_t filter_index) const override;
 
@@ -199,6 +203,15 @@ public:
                                     frag_hasher,
                                     std::equal_to<string_fragment>>;
 
+    static std::optional<row_type> row_type_from_string(const std::string& str);
+    static const char* row_type_to_string(row_type rt);
+
+    void set_row_type_visibility(row_type rt, bool visible);
+    bool is_row_type_visible(row_type rt) const;
+
+    std::set<row_type> gs_hidden_row_types;
+    std::set<row_type> gs_preview_hidden_row_types;
+
     timeline_preview_overlay gs_preview_overlay;
     attr_line_t gs_rendered_line;
     size_t gs_opid_width{0};