Flag to allow debugging parse failures

src/log.rs

@@ -11,14 +11,16 @@ pub struct Log<Format> {
 }
 
 impl<Format> Log<Format> {
-    pub fn parse(yaml: &str) -> Option<Self> {
+    pub fn parse(yaml: &str, include_failures: bool) -> Option<Self> {
         let cleaned = strip_ansi_escapes::strip_str(yaml);
 
         match serde_yaml::from_str(&cleaned) {
             Ok(log) => Some(log),
             Err(e) => {
-                eprintln!("Failed to parse YAML: {}", e);
-                eprintln!("YAML content:\n{}", cleaned);
+                if include_failures {
+                    eprintln!("Failed to parse YAML: {}", e);
+                    eprintln!("YAML content:\n{}", cleaned);
+                }
                 None
             }
         }
@@ -113,7 +115,7 @@ mod tests {
 
                 let expected_output = format!($expected_output);
                 assert_eq!(
-                    Log::<$format>::parse(yaml_data).unwrap().to_string(),
+                    Log::<$format>::parse(yaml_data, true).unwrap().to_string(),
                     expected_output
                 );
             }

src/main.rs

@@ -44,6 +44,10 @@ struct Args {
 
     #[clap(subcommand)]
     command: Command,
+
+    /// whether to include logs that fail to parse
+    #[clap(short, long, global = true)]
+    include_failures: bool,
 }
 
 #[derive(Parser, Debug)]
@@ -64,7 +68,7 @@ enum Command {
 }
 
 impl Command {
-    async fn run<F>(self, project: &str, filter: &str) -> anyhow::Result<()>
+    async fn run<F>(self, project: &str, filter: &str, include_failures: bool) -> anyhow::Result<()>
     where
         Log<F>: std::fmt::Display + 'static,
     {
@@ -90,6 +94,7 @@ impl Command {
                             .take()
                             .ok_or(anyhow!("Failed to capture stdout"))?,
                     ),
+                    include_failures,
                 )
                 .await?
             }
@@ -107,6 +112,7 @@ impl Command {
                                 .take()
                                 .ok_or(anyhow!("Failed to capture stdout"))?,
                         ),
+                        include_failures,
                     ));
 
                     let mut new_filters;
@@ -131,6 +137,7 @@ async fn main() {
     std::env::set_var("CLOUDSDK_PYTHON_SITEPACKAGES", "1");
     let Args {
         filter,
+        include_failures,
         pretty,
         project,
         command,
@@ -155,10 +162,22 @@ async fn main() {
 
     if let Err(e) = match pretty {
         true => match atty::is(Stream::Stdout) {
-            true => command.run::<Decorated>(&project, &filter).await,
-            false => command.run::<Pretty>(&project, &filter).await,
+            true => {
+                command
+                    .run::<Decorated>(&project, &filter, include_failures)
+                    .await
+            }
+            false => {
+                command
+                    .run::<Pretty>(&project, &filter, include_failures)
+                    .await
+            }
         },
-        false => command.run::<Raw>(&project, &filter).await,
+        false => {
+            command
+                .run::<Raw>(&project, &filter, include_failures)
+                .await
+        }
     } {
         eprintln!("Error: {}", e);
         exit(1);

src/stream.rs

@@ -6,6 +6,7 @@ use crate::log::Log;
 pub async fn transpose<F>(
     mut writer: impl std::io::Write,
     reader: impl AsyncBufRead + Unpin,
+    include_failures: bool,
 ) -> std::io::Result<()>
 where
     Log<F>: std::fmt::Display,
@@ -18,13 +19,14 @@ where
         if line == "---" {
             // Parse the collected YAML block if it's non-empty
             if !yaml_buffer.trim().is_empty() {
-                match Log::<F>::parse(&yaml_buffer) {
+                match Log::<F>::parse(&yaml_buffer, include_failures) {
                     Some(entry) => {
                         write!(writer, "{entry}")?;
                     }
-                    None => {
+                    None if include_failures => {
                         eprintln!("Failed to parse log entry:\n{}", yaml_buffer);
                     }
+                    None => {}
                 }
                 yaml_buffer.clear();
             }
@@ -64,7 +66,7 @@ mod tests {
         let reader = BufReader::new(Cursor::new(log_data));
         let mut result = Vec::new();
 
-        transpose::<Raw>(&mut result, reader).await.unwrap();
+        transpose::<Raw>(&mut result, reader, true).await.unwrap();
         let result = String::from_utf8(result).unwrap();
         assert_eq!(result, "Test message");
     }