a bit of error context

Cargo.toml

@@ -16,7 +16,7 @@ version = "1.0.0-alpha.2"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0.32"
+anyhow = {version = "1.0.32", features = ["backtrace"]}
 async-compression = {version = "0.3.15", features = ["all", "all-algorithms", "tokio"]}
 async-stream = "0.3.3"
 async-trait = "0.1.64"

src/adapters/custom.rs

@@ -143,15 +143,13 @@ pub fn map_exe_error(err: std::io::Error, exe_name: &str, help: &str) -> anyhow:
     }
 }
 
-fn proc_wait(mut child: Child) -> impl AsyncRead {
+fn proc_wait(mut child: Child, context: impl FnOnce() -> String) -> impl AsyncRead {
     let s = stream! {
         let res = child.wait().await?;
         if res.success() {
             yield std::io::Result::Ok(Bytes::new());
         } else {
-            yield std::io::Result::Err(to_io_err(
-                format_err!("subprocess failed: {:?}", res),
-            ));
+            Err(format_err!("{:?}", res)).with_context(context).map_err(to_io_err)?;
         }
     };
     StreamReader::new(s)
@@ -164,6 +162,7 @@ pub fn pipe_output(
     exe_name: &str,
     help: &str,
 ) -> Result<ReadBox> {
+    let cmd_log = format!("{:?}", cmd); // todo: perf
     let mut cmd = cmd
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
@@ -177,10 +176,9 @@ pub fn pipe_output(
         tokio::io::copy(&mut z, &mut stdi).await?;
         std::io::Result::Ok(())
     });
-
-    Ok(Box::pin(
-        stdo.chain(proc_wait(cmd).chain(join_handle_to_stream(join))),
-    ))
+    Ok(Box::pin(stdo.chain(
+        proc_wait(cmd, move || format!("subprocess: {cmd_log}")).chain(join_handle_to_stream(join)),
+    )))
 }
 
 pub struct CustomSpawningFileAdapter {

src/adapters/sqlite.rs

@@ -77,11 +77,13 @@ fn synchronous_dump_sqlite(ai: AdaptInfo, mut s: impl Write) -> Result<()> {
         return Ok(());
     }
     let inp_fname = filepath_hint;
-
-    let conn = Connection::open_with_flags(inp_fname, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
+    let conn = Connection::open_with_flags(&inp_fname, OpenFlags::SQLITE_OPEN_READ_ONLY)
+        .with_context(|| format!("opening sqlite connection to {}", inp_fname.display()))?;
     let tables: Vec<String> = conn
-        .prepare("select name from sqlite_master where type='table'")?
-        .query_map([], |r| r.get::<_, String>(0))?
+        .prepare("select name from sqlite_master where type='table'")
+        .context("while preparing query")?
+        .query_map([], |r| r.get::<_, String>(0))
+        .context("while executing query")?
         .filter_map(|e| e.ok())
         .collect();
     debug!("db has {} tables", tables.len());
@@ -121,7 +123,9 @@ impl WritingFileAdapter for SqliteAdapter {
         oup: Pin<Box<dyn AsyncWrite + Send>>,
     ) -> Result<()> {
         let oup_sync = SyncIoBridge::new(oup);
-        tokio::task::spawn_blocking(|| synchronous_dump_sqlite(ai, oup_sync)).await??;
+        tokio::task::spawn_blocking(|| synchronous_dump_sqlite(ai, oup_sync))
+            .await?
+            .context("in synchronous sqlite task")?;
         Ok(())
     }
 }

src/adapters/writing.rs

@@ -3,7 +3,7 @@ use std::pin::Pin;
 use crate::{adapted_iter::one_file, join_handle_to_stream, to_io_err};
 
 use super::{AdaptInfo, FileAdapter, GetMetadata};
-use anyhow::Result;
+use anyhow::{Context, Result};
 use async_trait::async_trait;
 use tokio::io::{AsyncReadExt, AsyncWrite};
 
@@ -51,6 +51,7 @@ where
         a: super::AdaptInfo,
         detection_reason: &crate::matching::FileMatcher,
     ) -> Result<crate::adapted_iter::AdaptedFilesIterBox> {
+        let name = self.metadata().name.clone();
         let (w, r) = tokio::io::duplex(128 * 1024);
         let d2 = detection_reason.clone();
         let archive_recursion_depth = a.archive_recursion_depth + 1;
@@ -60,7 +61,10 @@ where
         let config = a.config.clone();
         let joiner = tokio::spawn(async move {
             let x = d2;
-            T::adapt_write(a, &x, Box::pin(w)).await.map_err(to_io_err)
+            T::adapt_write(a, &x, Box::pin(w))
+                .await
+                .with_context(|| format!("in {}.adapt_write", name))
+                .map_err(to_io_err)
         });
 
         Ok(one_file(AdaptInfo {

src/bin/rga-preproc.rs

@@ -43,7 +43,7 @@ async fn main() -> anyhow::Result<()> {
             // happens if e.g. ripgrep detects binary data in the pipe so it cancels reading
             debug!("output cancelled (broken pipe)");
         } else {
-            Err(e).context("copying adapter output to stdout {}")?;
+            Err(e).context("copying adapter output to stdout")?;
         }
     }
     debug!("running adapter took {} total", print_dur(start));