chalk-remote-call-python 1.8.2__tar.gz → 1.8.5__tar.gz

{chalk_remote_call_python-1.8.2/chalk_remote_call_python.egg-info → chalk_remote_call_python-1.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.8.2
+Version: 1.8.5
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/Cargo.lock

@@ -3607,6 +3607,16 @@ dependencies = [
  "tracing-core",
 ]
 
+[[package]]
+name = "tracing-serde"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
 [[package]]
 name = "tracing-subscriber"
 version = "0.3.23"
@@ -3617,12 +3627,15 @@ dependencies = [
  "nu-ansi-term",
  "once_cell",
  "regex-automata",
+ "serde",
+ "serde_json",
  "sharded-slab",
  "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
  "tracing-log",
+ "tracing-serde",
 ]
 
 [[package]]

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -19,7 +19,7 @@ tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "signa
 tokio-stream = "0.1"
 arrow = { version = "54", default-features = false, features = ["ipc"] }
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 bytes = "1"
 uuid = { version = "1", features = ["v4"] }
 dashmap = "5"

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/async_service.rs

@@ -190,7 +190,12 @@ impl AsyncRemoteCallService for AsyncRemoteCallServiceImpl {
                     Err(e) => {
                         s.status = RemoteCallStatus::Failed;
                         s.error = Some(e.to_string());
-                        error!(call_id = %id, error = %e, "async call failed");
+                        error!(
+                            call_id = %id,
+                            exception.stacktrace = e.details(),
+                            "async call failed: {}",
+                            e.details()
+                        );
                     }
                 }
             }

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/coalesce.rs

@@ -176,7 +176,11 @@ impl CoalescingQueue {
                 }
             }
             Err(e) => {
-                error!("Coalesced handler error: {}", e);
+                error!(
+                    exception.stacktrace = e.details(),
+                    "Coalesced handler error: {}",
+                    e.details()
+                );
                 // IPC decode errors are already caught by the service's
                 // pre-validation; anything reaching here is a handler error.
                 #[cfg(target_os = "linux")]

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/lib.rs

@@ -44,8 +44,12 @@ fn start_server(
     max_batching_size: usize,
     max_buffer_duration_ms: u64,
 ) -> PyResult<()> {
-    // Initialize tracing (respects RUST_LOG env var, defaults to info)
+    // Kubernetes consumes stdout/stderr as a machine-readable log stream. Keep
+    // event fields flattened so collectors can read `level`, `target`,
+    // `message`, and fields such as `error` without parsing terminal output.
     let _ = tracing_subscriber::fmt()
+        .json()
+        .flatten_event(true)
         .with_env_filter(
             EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
         )

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/python_bridge.rs

@@ -74,7 +74,7 @@ impl PythonHandler {
             })
         })
         .await
-        .map_err(|e| PythonError(format!("Task join error: {e}")))?
+        .map_err(|e| PythonError::new(format!("Task join error: {e}")))?
     }
 
     /// Non-batched streaming dispatch. Calls `process_batches(..., emit)` so
@@ -147,7 +147,7 @@ impl PythonHandler {
             })
         })
         .await
-        .map_err(|e| PythonError(format!("Task join error: {e}")))?
+        .map_err(|e| PythonError::new(format!("Task join error: {e}")))?
     }
 }
 
@@ -305,13 +305,13 @@ fn invoke_process_fn(
     let result_list: &Bound<'_, PyList> = result
         .bind(py)
         .cast::<PyList>()
-        .map_err(|e| PythonError(format!("bridge must return a list, got: {e}")))?;
+        .map_err(|e| PythonError::new(format!("bridge must return a list, got: {e}")))?;
 
     let mut out = Vec::with_capacity(result_list.len());
     for item in result_list.iter() {
-        let bytes_ref: &Bound<'_, PyBytes> = item
-            .cast::<PyBytes>()
-            .map_err(|e| PythonError(format!("bridge must return list[bytes], got item: {e}")))?;
+        let bytes_ref: &Bound<'_, PyBytes> = item.cast::<PyBytes>().map_err(|e| {
+            PythonError::new(format!("bridge must return list[bytes], got item: {e}"))
+        })?;
         out.push(bytes_ref.as_bytes().to_vec());
     }
     Ok(out)
@@ -319,14 +319,38 @@ fn invoke_process_fn(
 
 /// Error type for Python handler invocations.
 #[derive(Debug)]
-pub struct PythonError(pub String);
+pub struct PythonError {
+    details: String,
+}
+
+impl PythonError {
+    fn new(message: String) -> Self {
+        Self { details: message }
+    }
+
+    pub fn details(&self) -> &str {
+        &self.details
+    }
+}
 
 impl std::fmt::Display for PythonError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
+        write!(f, "{}", self.details)
     }
 }
 
 fn into_python_error(py: Python<'_>, err: PyErr) -> PythonError {
-    PythonError(format!("{}", err.value(py)))
+    let summary = err.to_string();
+    let details = format_python_traceback(py, &err).unwrap_or_else(|_| summary.clone());
+    PythonError { details }
+}
+
+fn format_python_traceback(py: Python<'_>, err: &PyErr) -> PyResult<String> {
+    let traceback = py.import("traceback")?;
+    let formatted = traceback.call_method1(
+        "format_exception",
+        (err.get_type(py), err.value(py), err.traceback(py)),
+    )?;
+    let lines: Vec<String> = formatted.extract()?;
+    Ok(lines.concat().trim_end().to_string())
 }

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/self_consumer.rs

@@ -609,16 +609,27 @@ async fn execute_and_write(
             info!(call_id = %work.call_id, chunks = flushed, "queued call completed");
         }
         Err(e) => {
-            // Parity with the enqueue/poll path: only a message string is
-            // available (no structured exc_type / traceback yet), so exc_type is
-            // a fixed placeholder.
-            stream_writer::write_error(conn, &stream_key, seq, "RemoteFunctionError", &e.0, None)
-                .await?;
-            let summary: String = e.0.chars().take(200).collect();
+            // The formatted Python traceback is available, but the concrete
+            // exception type is not carried separately across this boundary.
+            stream_writer::write_error(
+                conn,
+                &stream_key,
+                seq,
+                "RemoteFunctionError",
+                e.details(),
+                None,
+            )
+            .await?;
+            let summary: String = e.to_string().chars().take(200).collect();
             let _ = queue
                 .complete_status(call_uuid, "failed", &summary, Some(processing_trace_id))
                 .await;
-            error!(call_id = %work.call_id, error = %e, "queued call failed");
+            error!(
+                call_id = %work.call_id,
+                exception.stacktrace = e.details(),
+                "queued call failed: {}",
+                e.details()
+            );
         }
     }
     Ok(())

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5}/chalk-remote-call-rs/chalk-remote-call-server/src/service.rs

@@ -139,7 +139,11 @@ impl RemoteCallService for RemoteCallServiceImpl {
                         // handler failure; nothing to send.
                         debug!("client disconnected during streaming response");
                     } else {
-                        error!("Python handler error: {}", e);
+                        error!(
+                            exception.stacktrace = e.details(),
+                            "Python handler error: {}",
+                            e.details()
+                        );
                         let _ = error_tx
                             .send(Err(Status::unknown(format!(
                                 "Exception raised during handler execution: {e}"

chalk_remote_call_python-1.8.5/chalk_remote_call/_version.py

@@ -0,0 +1 @@
+__version__ = "1.8.5"

{chalk_remote_call_python-1.8.2 → chalk_remote_call_python-1.8.5/chalk_remote_call_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.8.2
+Version: 1.8.5
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai

chalk_remote_call_python-1.8.2/chalk_remote_call/_version.py

@@ -1 +0,0 @@
-__version__ = "1.8.2"