Support for multiline log messages

Author: Paulo Remoli

CHANGELOG.md

@@ -7,6 +7,7 @@ All notable changes to logana will be documented in this file.
 ### Added
 - Mouse support
 - Support for compressed and archive files: `.gz`, `.bz2`, `.xz`, `.zip`, `.tar`, `.tar.gz`/`.tgz`, `.tar.bz2`/`.tbz2`, `.tar.xz`/`.txz`.
+- Support for multiline log message, previously each line was treated as separate entry.
 
 ### Fixed
 - Show an error in the notification bar on startup when the config file exists but cannot be read or parsed

src/ui/loading.rs

@@ -1070,6 +1070,16 @@ impl App {
                     tab.filter.match_counts = counts;
                 }
                 if is_last {
+                    // Apply continuation-line grouping: continuation lines
+                    // (those whose parser returned None) inherit their parent's
+                    // filter visibility so they are hidden when the parent is
+                    // hidden (e.g. by a date or exclude filter).
+                    if let Some(cmap) = tab.continuation_map.clone() {
+                        super::apply_continuation_correction(
+                            &mut tab.filter.visible_indices,
+                            &cmap,
+                        );
+                    }
                     if let Some(idx) = scroll_anchor
                         && let Some(pos) = tab.filter.visible_indices.position_of(idx)
                     {

src/ui/tab_state/mod.rs

@@ -306,6 +306,14 @@ impl VisibleLines {
         (0..len).map(move |i| self.get(i))
     }
 
+    /// Returns `true` if file-line `idx` is in the visible set.
+    pub fn contains(&self, idx: usize) -> bool {
+        match self {
+            Self::All(n) => idx < *n,
+            Self::Filtered(v) => v.binary_search(&idx).is_ok(),
+        }
+    }
+
     /// Binary search for file-line index `target`.
     /// Returns `Ok(pos)` if found, `Err(insert_pos)` otherwise.
     pub fn binary_search(&self, target: usize) -> Result<usize, usize> {
@@ -394,6 +402,57 @@ pub fn display_text_for_line(
     String::from_utf8_lossy(bytes).into_owned()
 }
 
+/// Build a map from each line index to its "parent" line index — the most
+/// recent preceding line (inclusive) that the parser recognised as a log
+/// entry start.  Continuation lines (e.g. stack-trace frames that have no
+/// timestamp/level) map to their nearest preceding parent; parent lines map
+/// to themselves.
+///
+/// Empty lines are never considered a new parent (they are already hidden by
+/// `compute_unfiltered_visible` when a format is active).
+pub fn build_continuation_map(reader: &FileReader, parser: &dyn LogFormatParser) -> Vec<usize> {
+    let count = reader.line_count();
+    let mut map = Vec::with_capacity(count);
+    let mut last_parent = 0usize;
+    for i in 0..count {
+        let line = reader.get_line(i);
+        if !line.is_empty() && parser.parse_line(line).is_some() {
+            last_parent = i;
+        }
+        map.push(last_parent);
+    }
+    map
+}
+
+/// Rewrite `visible` so that every continuation line (one whose parent differs
+/// from itself in `cmap`) is visible iff its parent is visible.
+///
+/// Parent lines are unaffected — their filter decision is preserved as-is.
+/// The output remains sorted because we iterate `0..n` in ascending order.
+pub fn apply_continuation_correction(visible: &mut VisibleLines, cmap: &[usize]) {
+    let indices = match visible {
+        VisibleLines::All(_) => return, // all lines visible — nothing to fix
+        VisibleLines::Filtered(v) => v,
+    };
+    let n = cmap.len();
+    // Build a flat boolean lookup: was each line kept by the filter?
+    let mut filter_visible = vec![false; n];
+    for &idx in indices.iter() {
+        if idx < n {
+            filter_visible[idx] = true;
+        }
+    }
+    // Rebuild the list: each line is visible iff its parent is visible.
+    indices.clear();
+    for i in 0..n {
+        let parent = cmap[i];
+        if filter_visible[parent] {
+            indices.push(i);
+        }
+    }
+    // The result is already sorted (we iterate 0..n in order).
+}
+
 pub struct TabState {
     pub file_reader: FileReader,
     pub log_manager: LogManager,
@@ -411,6 +470,10 @@ pub struct TabState {
     /// Some(fraction 0.0–1.0) while this tab's content is being extracted from an archive.
     /// None when waiting for its turn, or after extraction completes.
     pub extraction_progress: Option<f64>,
+    /// Maps each line index to the nearest preceding line index (inclusive)
+    /// that the log-format parser recognised as an entry start.  `None` when
+    /// no format has been detected or raw-mode is active.
+    pub continuation_map: Option<Arc<Vec<usize>>>,
 }
 
 impl TabState {
@@ -428,6 +491,10 @@ impl TabState {
             .unwrap_or_default();
         let fields_hidden_by_default = !default_hidden.is_empty();
 
+        let continuation_map = detected_format
+            .as_deref()
+            .map(|p| Arc::new(build_continuation_map(&file_reader, p)));
+
         let mut tab = TabState {
             file_reader,
             log_manager,
@@ -466,6 +533,7 @@ impl TabState {
             load_state: None,
             archive_temp: None,
             extraction_progress: None,
+            continuation_map,
         };
         tab.refresh_visible();
         tab
@@ -1476,6 +1544,22 @@ impl TabState {
             return;
         }
 
+        // Extend the continuation map for the newly-appended lines.
+        if let (Some(cmap), Some(parser)) = (
+            self.continuation_map.as_mut(),
+            self.display.format.as_deref().filter(|_| !self.display.raw_mode),
+        ) {
+            let map = Arc::make_mut(cmap);
+            let mut last_parent = map.last().copied().unwrap_or(0);
+            for i in old_line_count..new_count {
+                let line = self.file_reader.get_line(i);
+                if !line.is_empty() && parser.parse_line(line).is_some() {
+                    last_parent = i;
+                }
+                map.push(last_parent);
+            }
+        }
+
         let has_active_filters =
             self.filter.show_marks_only || self.log_manager.get_filters().iter().any(|f| f.enabled);
 
@@ -1613,6 +1697,25 @@ impl TabState {
             }
         }
 
+        // Apply continuation semantics: continuation lines inherit their parent's
+        // filter decision. A parent in this batch uses `new_visible`; a parent
+        // from earlier uses `visible_indices`.
+        if let Some(cmap) = self.continuation_map.clone() {
+            let existing = &self.filter.visible_indices;
+            let new_vis_set: std::collections::HashSet<usize> =
+                new_visible.iter().copied().collect();
+            new_visible.retain(|&i| {
+                let parent = cmap.get(i).copied().unwrap_or(i);
+                if parent == i {
+                    true
+                } else if parent >= old_line_count {
+                    new_vis_set.contains(&parent)
+                } else {
+                    existing.contains(parent)
+                }
+            });
+        }
+
         match &mut self.filter.visible_indices {
             VisibleLines::All(n) => {
                 *n = new_count;
@@ -1847,6 +1950,11 @@ impl TabState {
                 }
             }
             self.display.format = fmt;
+            self.continuation_map = self
+                .display
+                .format
+                .as_deref()
+                .map(|p| Arc::new(build_continuation_map(&self.file_reader, p)));
         }
     }
 

src/ui/widgets/log_panel.rs

@@ -606,7 +606,36 @@ pub fn prepare_log_panel(
             let level = cached
                 .and_then(|c| c.level.as_deref())
                 .map(LogLevel::parse_level)
-                .unwrap_or_else(|| LogLevel::detect_from_bytes(line_bytes));
+                .unwrap_or_else(|| {
+                    // For continuation lines (parse_line returned None), inherit
+                    // the parent entry's level so the whole multiline block gets
+                    // the same color (e.g. a stack trace stays red under ERROR).
+                    if let Some(cmap) = &tab.continuation_map {
+                        let parent = cmap.get(line_idx).copied().unwrap_or(line_idx);
+                        if parent != line_idx {
+                            // Try the parent's cache entry first.
+                            if let Some(lvl) = tab
+                                .cache
+                                .parse
+                                .get(&parent)
+                                .filter(|(g, _)| *g == parse_gen)
+                                .and_then(|(_, c)| c.level.as_deref())
+                            {
+                                return LogLevel::parse_level(lvl);
+                            }
+                            // Parent not cached (outside viewport) — parse just
+                            // the level from its raw bytes without full layout.
+                            if let Some(parser) = tab.display.format.as_deref() {
+                                if let Some(parts) = parser.parse_line(tab.file_reader.get_line(parent)) {
+                                    if let Some(lvl) = parts.level {
+                                        return LogLevel::parse_level(lvl);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    LogLevel::detect_from_bytes(line_bytes)
+                });
             match level {
                 LogLevel::Trace if !level_colors_disabled.contains("trace") => {
                     base_style = base_style.fg(theme.trace_fg)

tests/integration.rs

@@ -616,3 +616,133 @@ fn test_detect_format_does_not_select_dlt_for_non_dlt() {
     let parser = detect_format(&lines).unwrap();
     assert_ne!(parser.name(), "dlt");
 }
+
+// ---------------------------------------------------------------------------
+// Multiline / continuation-line tests
+// ---------------------------------------------------------------------------
+
+/// Build a FileReader from a multiline log string with Java-style stack traces.
+fn make_multiline_log() -> FileReader {
+    // Line 0: ERROR entry with timestamp (parent)
+    // Line 1: stack frame (continuation)
+    // Line 2: stack frame (continuation)
+    // Line 3: INFO entry with timestamp (standalone parent)
+    let data = b"\
+2024-01-15 10:00:00 ERROR com.example.App - NullPointerException\n\
+    at com.example.Foo.bar(Foo.java:42)\n\
+    at com.example.Main.main(Main.java:10)\n\
+2024-01-16 11:00:00 INFO  com.example.App - Application started\n";
+    FileReader::from_bytes(data.to_vec())
+}
+
+#[test]
+fn test_build_continuation_map_basic() {
+    use logana::parser::detect_format;
+    use logana::ui::build_continuation_map;
+
+    let reader = make_multiline_log();
+    let sample: Vec<&[u8]> = (0..reader.line_count()).map(|i| reader.get_line(i)).collect();
+    let parser = detect_format(&sample).expect("format should be detected");
+
+    let cmap = build_continuation_map(&reader, parser.as_ref());
+
+    assert_eq!(cmap.len(), 4);
+    assert_eq!(cmap[0], 0, "line 0 is its own parent");
+    assert_eq!(cmap[1], 0, "line 1 is a continuation of line 0");
+    assert_eq!(cmap[2], 0, "line 2 is a continuation of line 0");
+    assert_eq!(cmap[3], 3, "line 3 is its own parent");
+}
+
+#[test]
+fn test_apply_continuation_correction_hides_orphaned_continuations() {
+    use logana::ui::{VisibleLines, apply_continuation_correction};
+
+    // Simulate: filter kept only line 3 (INFO); lines 0, 1, 2 were filtered.
+    // Without correction, continuation lines 1 and 2 might still be visible.
+    // With correction they must be hidden because their parent (line 0) is hidden.
+    let cmap = vec![0usize, 0, 0, 3]; // lines 1,2 → parent 0; line 3 → parent 3
+    let mut visible = VisibleLines::Filtered(vec![1, 2, 3]); // lines 1 & 2 erroneously visible
+    apply_continuation_correction(&mut visible, &cmap);
+    // line 0 was NOT in visible, so its continuations (1, 2) must be removed.
+    // line 3 is its own parent and was visible → stays.
+    assert_eq!(visible, VisibleLines::Filtered(vec![3]));
+}
+
+#[test]
+fn test_apply_continuation_correction_keeps_continuations_with_parent() {
+    use logana::ui::{VisibleLines, apply_continuation_correction};
+
+    // Simulate: filter kept line 0 (ERROR parent); continuations 1 and 2 also passed.
+    let cmap = vec![0usize, 0, 0, 3];
+    let mut visible = VisibleLines::Filtered(vec![0, 1, 2, 3]);
+    apply_continuation_correction(&mut visible, &cmap);
+    // Parent 0 is visible → continuations 1 and 2 stay visible.
+    assert_eq!(visible, VisibleLines::Filtered(vec![0, 1, 2, 3]));
+}
+
+#[test]
+fn test_apply_continuation_correction_noop_for_all_variant() {
+    use logana::ui::{VisibleLines, apply_continuation_correction};
+
+    let cmap = vec![0usize, 0, 1];
+    let mut visible = VisibleLines::All(3);
+    apply_continuation_correction(&mut visible, &cmap);
+    // All-variant must remain unchanged.
+    assert_eq!(visible, VisibleLines::All(3));
+}
+
+#[tokio::test]
+async fn test_exclude_filter_hides_continuation_lines() {
+    use logana::filters::FilterType;
+    use logana::parser::detect_format;
+    use logana::ui::{VisibleLines, apply_continuation_correction, build_continuation_map};
+
+    let (_db, mut manager) = setup().await;
+    let reader = make_multiline_log();
+    let sample: Vec<&[u8]> = (0..reader.line_count()).map(|i| reader.get_line(i)).collect();
+    let parser = detect_format(&sample).expect("format detected");
+    let cmap = build_continuation_map(&reader, parser.as_ref());
+
+    // Exclude lines containing "ERROR" — should hide line 0 AND its continuations
+    manager
+        .add_filter_with_color("ERROR".into(), FilterType::Exclude, None, None, true)
+        .await;
+    let (fm, _, _, _) = manager.build_filter_manager();
+    let mut visible = VisibleLines::Filtered(fm.compute_visible(&reader));
+    apply_continuation_correction(&mut visible, &cmap);
+
+    // Line 0 (ERROR) excluded; lines 1 & 2 are its continuations → also excluded.
+    // Line 3 (INFO) should be visible.
+    assert!(!visible.contains(0), "ERROR entry should be hidden");
+    assert!(!visible.contains(1), "continuation 1 should be hidden with parent");
+    assert!(!visible.contains(2), "continuation 2 should be hidden with parent");
+    assert!(visible.contains(3), "INFO entry should be visible");
+}
+
+#[tokio::test]
+async fn test_include_filter_shows_continuations_with_parent() {
+    use logana::filters::FilterType;
+    use logana::parser::detect_format;
+    use logana::ui::{VisibleLines, apply_continuation_correction, build_continuation_map};
+
+    let (_db, mut manager) = setup().await;
+    let reader = make_multiline_log();
+    let sample: Vec<&[u8]> = (0..reader.line_count()).map(|i| reader.get_line(i)).collect();
+    let parser = detect_format(&sample).expect("format detected");
+    let cmap = build_continuation_map(&reader, parser.as_ref());
+
+    // Include only lines containing "ERROR" — parent matches; continuations should follow.
+    manager
+        .add_filter_with_color("ERROR".into(), FilterType::Include, None, None, true)
+        .await;
+    let (fm, _, _, _) = manager.build_filter_manager();
+    let mut visible = VisibleLines::Filtered(fm.compute_visible(&reader));
+    apply_continuation_correction(&mut visible, &cmap);
+
+    // Line 0 matches; its continuations (1, 2) should be shown.
+    // Line 3 (INFO) does not match include → hidden.
+    assert!(visible.contains(0), "ERROR entry should be visible");
+    assert!(visible.contains(1), "continuation 1 should follow its visible parent");
+    assert!(visible.contains(2), "continuation 2 should follow its visible parent");
+    assert!(!visible.contains(3), "INFO entry should be hidden (no match)");
+}