feat(subprocess-error): enhance error handling/message for subprocess

Author: georgeh0

python/cocoindex/subprocess_exec.py

@@ -152,6 +152,16 @@ def _watch() -> None:
 
 
 def _subprocess_init(user_apps: list[str], parent_pid: int) -> None:
+    import signal
+    import faulthandler
+
+    faulthandler.enable()
+    # Ignore SIGINT in the subprocess on best-effort basis.
+    try:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+    except Exception:
+        pass
+
     _start_parent_watchdog(parent_pid)
 
     # In case any user app is already in this subprocess, e.g. the subprocess is forked, we need to avoid loading it again.
@@ -193,10 +203,15 @@ class _ExecutorEntry:
 
 def _call_method(method: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
     """Run an awaitable/coroutine to completion synchronously, otherwise return as-is."""
-    if asyncio.iscoroutinefunction(method):
-        return asyncio.run(method(*args, **kwargs))
-    else:
-        return method(*args, **kwargs)
+    try:
+        if asyncio.iscoroutinefunction(method):
+            return asyncio.run(method(*args, **kwargs))
+        else:
+            return method(*args, **kwargs)
+    except Exception as e:
+        raise RuntimeError(
+            f"Error calling method `{method.__name__}` from subprocess"
+        ) from e
 
 
 def _get_or_create_entry(key_bytes: bytes) -> _ExecutorEntry:

src/py/mod.rs

@@ -10,6 +10,7 @@ use crate::server::{self, ServerSettings};
 use crate::settings::Settings;
 use crate::setup::{self};
 use pyo3::IntoPyObjectExt;
+use pyo3::types::{PyDict, PyIterator, PyModule};
 use pyo3::{exceptions::PyException, prelude::*};
 use pyo3_async_runtimes::tokio::future_into_py;
 use std::fmt::Write;
@@ -37,10 +38,34 @@ impl<T> ToResultWithPyTrace<T> for Result<T, PyErr> {
         match self {
             Ok(value) => Ok(value),
             Err(err) => {
-                let mut err_str = format!("Error calling Python function: {err}");
-                if let Some(tb) = err.traceback(py) {
-                    write!(&mut err_str, "\n{}", tb.format()?)?;
-                }
+                // Attempt to render a full Python-style traceback including cause/context chain
+                let full_trace: PyResult<String> = (|| {
+                    let exc = err.value(py);
+                    let traceback = PyModule::import(py, "traceback")?;
+                    let tbe_class = traceback.getattr("TracebackException")?;
+                    let tbe = tbe_class.call_method1("from_exception", (exc,))?;
+                    let kwargs = PyDict::new(py);
+                    kwargs.set_item("chain", true)?;
+                    let lines = tbe.call_method("format", (), Some(&kwargs))?;
+                    let iter = PyIterator::from_object(&lines)?;
+                    let parts: Vec<String> = iter
+                        .map(|item| item.and_then(|i| i.extract::<String>()))
+                        .collect::<PyResult<_>>()?;
+                    Ok(parts.join(""))
+                })();
+
+                let err_str = match full_trace {
+                    Ok(trace) => format!("Error calling Python function:\n{trace}"),
+                    Err(_) => {
+                        // Fallback: include the PyErr display and available traceback formatting
+                        let mut s = format!("Error calling Python function: {err}");
+                        if let Some(tb) = err.traceback(py) {
+                            write!(&mut s, "\n{}", tb.format()?).ok();
+                        }
+                        s
+                    }
+                };
+
                 Err(anyhow::anyhow!(err_str))
             }
         }