[integration] tweaks needed to integrate with lnav

Mostly need to make some more fields public so
lnav can read them.

Also, restore checking if the file name mentioned
in the log is in the discovered source path.  The
check is pretty loose since I think I've seen
file names truncated before.

Author: tstack

src/lib.rs

@@ -48,6 +48,7 @@ pub enum LogError {
 /// Collection of log statements in a single source file
 #[derive(Debug)]
 pub struct StatementsInFile {
+    pub filename: String,
     pub log_statements: Vec<SourceRef>,
     /// A single matcher for all log statements.
     /// XXX If there are too many in the file, the RegexSet constructor
@@ -165,17 +166,36 @@ impl LogMatcher {
     /// Attempt to match the given log message.
     pub fn match_log_statement<'a>(&self, log_ref: &LogRef<'a>) -> Option<LogMapping<'a>> {
         for (_path, coll) in &self.roots {
-            let matches = coll
-                .statements
-                .par_iter()
-                .flat_map(|src_ref_coll| {
-                    let file_matches = src_ref_coll.matcher.matches(log_ref.body());
-                    match file_matches.iter().next() {
-                        None => None,
-                        Some(index) => src_ref_coll.log_statements.get(index),
-                    }
-                })
-                .collect::<Vec<&SourceRef>>();
+            let matches = if let Some(LogDetails {
+                file: Some(filename),
+                body: Some(body),
+                ..
+            }) = log_ref.details
+            {
+                // XXX this block and the else are basically the same, try to refactor
+                coll.statements
+                    .iter()
+                    .filter(|stmts| stmts.filename.contains(filename))
+                    .flat_map(|stmts| {
+                        let file_matches = stmts.matcher.matches(body);
+                        match file_matches.iter().next() {
+                            None => None,
+                            Some(index) => stmts.log_statements.get(index),
+                        }
+                    })
+                    .collect::<Vec<&SourceRef>>()
+            } else {
+                coll.statements
+                    .par_iter()
+                    .flat_map(|src_ref_coll| {
+                        let file_matches = src_ref_coll.matcher.matches(log_ref.body());
+                        match file_matches.iter().next() {
+                            None => None,
+                            Some(index) => src_ref_coll.log_statements.get(index),
+                        }
+                    })
+                    .collect::<Vec<&SourceRef>>()
+            };
             if let Some(src_ref) = matches.first() {
                 let variables = extract_variables(log_ref, src_ref);
                 return Some(LogMapping {
@@ -268,24 +288,14 @@ pub struct LogMapping<'a> {
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct LogRef<'a> {
     pub line: &'a str,
-    details: Option<LogDetails<'a>>,
-}
-
-impl<'a> LogRef<'a> {
-    pub fn body(self) -> &'a str {
-        if let Some(LogDetails { body: Some(s), .. }) = self.details {
-            s
-        } else {
-            self.line
-        }
-    }
+    pub details: Option<LogDetails<'a>>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
-struct LogDetails<'a> {
-    file: Option<&'a str>,
-    lineno: Option<u32>,
-    body: Option<&'a str>,
+pub struct LogDetails<'a> {
+    pub file: Option<&'a str>,
+    pub lineno: Option<u32>,
+    pub body: Option<&'a str>,
 }
 
 impl<'a> LogRef<'a> {
@@ -296,6 +306,18 @@ impl<'a> LogRef<'a> {
         }
     }
 
+    pub fn from_parsed(file: Option<&'a str>, lineno: Option<u32>, body: &'a str) -> Self {
+        let details = Some(LogDetails {
+            file,
+            lineno,
+            body: Some(body),
+        });
+        Self {
+            line: body,
+            details,
+        }
+    }
+
     pub fn with_format(line: &'a str, log_format: LogFormat) -> Self {
         let captures = log_format.captures(line);
         let file = captures.name("file").map(|file_match| file_match.as_str());
@@ -308,6 +330,14 @@ impl<'a> LogRef<'a> {
             details: Some(LogDetails { file, lineno, body }),
         }
     }
+
+    pub fn body(self) -> &'a str {
+        if let Some(LogDetails { body: Some(s), .. }) = self.details {
+            s
+        } else {
+            self.line
+        }
+    }
 }
 
 pub fn link_to_source<'a>(log_ref: &LogRef, src_refs: &'a [SourceRef]) -> Option<&'a SourceRef> {
@@ -364,7 +394,7 @@ pub fn extract_variables<'a>(
     variables
 }
 
-pub fn filter_log<R>(buffer: &str, filter: R, log_format: Option<String>) -> Vec<LogRef>
+pub fn filter_log<R>(buffer: &str, filter: R, log_format: Option<String>) -> Vec<LogRef<'_>>
 where
     R: RangeBounds<usize>,
 {
@@ -432,6 +462,7 @@ pub fn extract_logging(sources: &[CodeSource], tracker: &ProgressTracker) -> Vec
                 None
             } else {
                 Some(StatementsInFile {
+                    filename: matched.first().unwrap().source_path.clone(),
                     log_statements: matched,
                     matcher: RegexSet::new(patterns).expect("To combine patterns"),
                 })

src/source_ref.rs

@@ -16,15 +16,15 @@ pub enum FormatArgument {
 #[derive(Clone, Debug, Serialize)]
 pub struct SourceRef {
     #[serde(rename(serialize = "sourcePath"))]
-    pub(crate) source_path: String,
+    pub source_path: String,
     #[serde(rename(serialize = "lineNumber"))]
     pub line_no: usize,
-    pub(crate) column: usize,
-    pub(crate) name: String,
-    pub(crate) text: String,
+    pub column: usize,
+    pub name: String,
+    pub text: String,
     #[serde(skip_serializing)]
     pub(crate) matcher: Regex,
-    pub(crate) pattern: String,
+    pub pattern: String,
     pub(crate) args: Vec<FormatArgument>,
     pub(crate) vars: Vec<String>,
 }