feat: support loading non-json lines

Author: c-git

src/app.rs

@@ -303,27 +303,23 @@ impl LogViewerApp {
                 ui.colored_label(ui.visuals().error_fg_color, msg);
             }
             LoadingStatus::Success(data) => {
-                self.loading_status =
-                // TODO 1: Make a copy of the loading type desired and match on it to get the data to load
-                    match Data::try_from((&self.data_display_options, &data[..])) {
-                        Ok(mut data) => {
-                            if let Some(old_data) = self.data.as_mut() {
-                                // Preserve settings across loads of the data
-                                data.take_config(
-                                    old_data,
-                                    self.data_display_options.common_fields(),
-                                );
-                            }
-                            self.data = Some(data);
-                            if self.should_scroll_to_end_on_load {
-                                self.move_selected_last();
-                            } else {
-                                self.should_scroll = true;
-                            }
-                            LoadingStatus::NotInProgress
+                self.loading_status = match Data::try_from((&self.data_display_options, &data[..]))
+                {
+                    Ok(mut data) => {
+                        if let Some(old_data) = self.data.as_mut() {
+                            // Preserve settings across loads of the data
+                            data.take_config(old_data, self.data_display_options.common_fields());
                         }
-                        Err(e) => LoadingStatus::Failed(clean_msg(format!("{e:?}"))),
+                        self.data = Some(data);
+                        if self.should_scroll_to_end_on_load {
+                            self.move_selected_last();
+                        } else {
+                            self.should_scroll = true;
+                        }
+                        LoadingStatus::NotInProgress
                     }
+                    Err(e) => LoadingStatus::Failed(clean_msg(format!("{e:?}"))),
+                }
             }
         }
     }

src/app/data.rs

@@ -9,7 +9,10 @@ use filter::{FieldSpecifier, FilterConfig};
 use log::warn;
 use serde_json::Value;
 
-use super::{calculate_hash, data_display_options::DataDisplayOptions};
+use super::{
+    calculate_hash,
+    data_display_options::{DataDisplayOptions, RowParseErrorHandling},
+};
 mod data_iter;
 pub mod filter;
 
@@ -364,8 +367,27 @@ impl TryFrom<(&DataDisplayOptions, usize, &str)> for LogRow {
     fn try_from(
         (data_display_options, row_idx_val, value): (&DataDisplayOptions, usize, &str),
     ) -> Result<Self, Self::Error> {
+        let data = match serde_json::from_str::<BTreeMap<String, Value>>(value) {
+            Ok(data) => data,
+            Err(e) => match &data_display_options.row_parse_error_handling {
+                RowParseErrorHandling::AbortOnAnyErrors => {
+                    Err(e).context("Parse Error and mode is Abort On Error")?
+                }
+                RowParseErrorHandling::ConvertFailedLines {
+                    raw_line_field_name,
+                    parse_error_field_name,
+                } => {
+                    let mut result = BTreeMap::new();
+                    result.insert(raw_line_field_name.clone(), value.into());
+                    if let Some(err_field) = parse_error_field_name {
+                        result.insert(err_field.clone(), format!("{e:?}").into());
+                    }
+                    result
+                }
+            },
+        };
         let mut result = Self {
-            data: serde_json::from_str(value)?,
+            data,
             cached_display_list: None,
         };
         if let Some(key) = data_display_options.row_idx_field_name.as_ref() {

src/app/data_display_options.rs

@@ -15,6 +15,19 @@ pub struct DataDisplayOptions {
 
     /// When set adds a field with this name and populates it with the row numbers
     pub row_idx_field_name: Option<String>,
+
+    /// Controls how errors during file loading are treated
+    pub row_parse_error_handling: RowParseErrorHandling,
+}
+
+#[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq)]
+pub enum RowParseErrorHandling {
+    AbortOnAnyErrors,
+    ConvertFailedLines {
+        raw_line_field_name: String,
+        /// If set the error message from the failure is placed in this field
+        parse_error_field_name: Option<String>,
+    },
 }
 
 impl DataDisplayOptions {
@@ -63,6 +76,16 @@ impl Default for DataDisplayOptions {
             .collect(),
             emphasize_if_matching_field_idx: Some(2),
             row_idx_field_name: Some("row#".to_string()),
+            row_parse_error_handling: Default::default(),
+        }
+    }
+}
+
+impl Default for RowParseErrorHandling {
+    fn default() -> Self {
+        Self::ConvertFailedLines {
+            raw_line_field_name: "msg".into(),
+            parse_error_field_name: Some("parse_err".into()),
         }
     }
 }