chalk-remote-call-python 1.9.0__tar.gz → 1.9.2__tar.gz

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.9.0
+Version: 1.9.2
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -108,6 +108,16 @@ python -m chalk_remote_call --handler my_handler.handler
 | `--on-shutdown` | | | Dotted path to a shutdown function |
 | `--log-level` | | `INFO` | `DEBUG`, `INFO`, `WARNING`, or `ERROR` |
 
+The CLI writes Python logs to stderr as one JSON object per line, with separate
+`timestamp`, `severity`, `logger`, and `message` fields. Exceptions include an
+`exception.stacktrace` field. Calls to `serve()` from Python retain the embedding
+application's logging configuration.
+
+Missing optional StatsD endpoints or a metrics-bus topic do not emit warnings.
+Failures initializing configured metrics sinks still warn. Routine customer
+StatsD configuration messages are emitted at DEBUG by the shared metrics library;
+set `RUST_LOG=info,chalk_metrics::metrics::config=debug` to include them.
+
 ### Environment variables
 
 | Variable | Description |
@@ -212,3 +222,23 @@ To check the Rust code independently:
 ```bash
 PYO3_PYTHON=python3 cargo check --manifest-path chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml
 ```
+
+## Remote exception transport
+
+Handler failures retain their original exception type, message, traceback,
+exception chains, and exception groups. Runtime dispatch frames are excluded
+from the user traceback; full diagnostics are retained in server logs.
+
+All call modes carry a JSON payload with `chalk_remote_error: 1` and an
+`exception` object containing the `ChalkException` fields `kind`, `message`,
+`stacktrace`, and `internal_stacktrace`. Direct calls carry the payload as the
+unescaped gRPC status message; queued calls carry it in the error message. The
+local async service additionally populates `ChalkError.exception`. This permits
+existing queue transports to forward structured errors without a protobuf
+migration. Clients must decode the versioned payload, not parse gRPC debug text
+or classify user errors by their message. Unknown versions remain opaque.
+
+Payloads are bounded for gRPC header limits. Truncation is marked explicitly,
+with complete tracebacks kept in server logs. Exception objects and locals are
+never pickled or sent. Chalk SDK-generated handlers identify their dispatch
+frames, and notebook source maps identify the deployed snapshot's lines.

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/README.md

@@ -70,6 +70,16 @@ python -m chalk_remote_call --handler my_handler.handler
 | `--on-shutdown` | | | Dotted path to a shutdown function |
 | `--log-level` | | `INFO` | `DEBUG`, `INFO`, `WARNING`, or `ERROR` |
 
+The CLI writes Python logs to stderr as one JSON object per line, with separate
+`timestamp`, `severity`, `logger`, and `message` fields. Exceptions include an
+`exception.stacktrace` field. Calls to `serve()` from Python retain the embedding
+application's logging configuration.
+
+Missing optional StatsD endpoints or a metrics-bus topic do not emit warnings.
+Failures initializing configured metrics sinks still warn. Routine customer
+StatsD configuration messages are emitted at DEBUG by the shared metrics library;
+set `RUST_LOG=info,chalk_metrics::metrics::config=debug` to include them.
+
 ### Environment variables
 
 | Variable | Description |
@@ -174,3 +184,23 @@ To check the Rust code independently:
 ```bash
 PYO3_PYTHON=python3 cargo check --manifest-path chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml
 ```
+
+## Remote exception transport
+
+Handler failures retain their original exception type, message, traceback,
+exception chains, and exception groups. Runtime dispatch frames are excluded
+from the user traceback; full diagnostics are retained in server logs.
+
+All call modes carry a JSON payload with `chalk_remote_error: 1` and an
+`exception` object containing the `ChalkException` fields `kind`, `message`,
+`stacktrace`, and `internal_stacktrace`. Direct calls carry the payload as the
+unescaped gRPC status message; queued calls carry it in the error message. The
+local async service additionally populates `ChalkError.exception`. This permits
+existing queue transports to forward structured errors without a protobuf
+migration. Clients must decode the versioned payload, not parse gRPC debug text
+or classify user errors by their message. Unknown versions remain opaque.
+
+Payloads are bounded for gRPC header limits. Truncation is marked explicitly,
+with complete tracebacks kept in server logs. Exception objects and locals are
+never pickled or sent. Chalk SDK-generated handlers identify their dispatch
+frames, and notebook source maps identify the deployed snapshot's lines.

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/Cargo.lock

@@ -484,7 +484,7 @@ dependencies = [
 [[package]]
 name = "chalk-core"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "anyhow",
  "envconfig",
@@ -499,7 +499,7 @@ dependencies = [
 [[package]]
 name = "chalk-protos"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "prost 0.11.9",
  "prost-build",
@@ -511,7 +511,7 @@ dependencies = [
 [[package]]
 name = "chalk-queue"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=9c61f6a938d8f885f138217ac64149e29d7a691e#9c61f6a938d8f885f138217ac64149e29d7a691e"
 dependencies = [
  "base64 0.22.1",
  "redis",
@@ -547,6 +547,7 @@ dependencies = [
  "prost 0.13.5",
  "pyo3",
  "redis",
+ "serde_json",
  "tokio",
  "tokio-stream",
  "tonic 0.12.3",
@@ -560,7 +561,7 @@ dependencies = [
 [[package]]
 name = "chalk_metric_definitions"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "chalk-protos",
  "metrics-generator",
@@ -570,7 +571,7 @@ dependencies = [
 [[package]]
 name = "chalk_metrics"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "async-trait",
  "chalk-core",
@@ -604,7 +605,7 @@ dependencies = [
 [[package]]
 name = "chalk_statsd"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "chalk-core",
  "chrono",
@@ -1867,7 +1868,7 @@ dependencies = [
 [[package]]
 name = "metrics-generator"
 version = "0.1.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=783e9ce6b2c#783e9ce6b2c17563ab3302e5d11f8a664ed00232"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=a0f8932ec10d3b8340af3e98cf63b800d60b4926#a0f8932ec10d3b8340af3e98cf63b800d60b4926"
 dependencies = [
  "codegen",
  "serde",

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -21,6 +21,7 @@ arrow = { version = "54", default-features = false, features = ["ipc"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 bytes = "1"
+serde_json = "1"
 uuid = { version = "1", features = ["v4"] }
 dashmap = "5"
 futures-util = "0.3"
@@ -34,8 +35,8 @@ futures-util = "0.3"
 # chalk-private commit, mirroring how chalkcompute_remote_client depends on
 # chalk_remote_call_client. chalk-queue declares `redis = "1.0.2"`; with no
 # `[patch.crates-io]` here it builds against vanilla crates.io redis (it only
-# uses standard APIs). Same rev across all three so cargo reuses one checkout.
+# uses standard APIs). Metrics and StatsD share a revision so their client types agree.
 [target.'cfg(target_os = "linux")'.dependencies]
-chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "783e9ce6b2c" }
-chalk_metrics = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "783e9ce6b2c" }
-chalk_statsd = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "783e9ce6b2c" }
+chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "9c61f6a938d8f885f138217ac64149e29d7a691e" }
+chalk_metrics = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "a0f8932ec10d3b8340af3e98cf63b800d60b4926" }
+chalk_statsd = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "a0f8932ec10d3b8340af3e98cf63b800d60b4926" }

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/chalk-remote-call-server/src/async_service.rs

@@ -39,7 +39,7 @@ struct CallState {
     /// and `status`/`error` can be updated without blocking emits.
     chunks: Arc<Mutex<ChunkBuffer>>,
     /// Populated only when `status == Failed`; surfaced as a `ChalkError`.
-    error: Option<String>,
+    error: Option<ChalkError>,
     /// When the call reached a terminal status. Used only by the orphan sweeper
     /// to decide when an un-drained terminal entry is safe to reclaim.
     completed_at: Option<Instant>,
@@ -189,7 +189,7 @@ impl AsyncRemoteCallService for AsyncRemoteCallServiceImpl {
                     }
                     Err(e) => {
                         s.status = RemoteCallStatus::Failed;
-                        s.error = Some(e.to_string());
+                        s.error = Some(e.chalk_error());
                         error!(
                             call_id = %id,
                             exception.stacktrace = e.details(),
@@ -246,10 +246,10 @@ impl AsyncRemoteCallService for AsyncRemoteCallServiceImpl {
         drop(buf);
 
         let errors = if status == RemoteCallStatus::Failed {
-            vec![ChalkError {
-                message: error.unwrap_or_else(|| "remote call failed".to_string()),
+            vec![error.unwrap_or_else(|| ChalkError {
+                message: "remote call failed".to_string(),
                 ..Default::default()
-            }]
+            })]
         } else {
             Vec::new()
         };

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/chalk-remote-call-server/src/coalesce.rs

@@ -193,8 +193,7 @@ impl CoalescingQueue {
                         chalk_metrics::metrics::tags::Mode::Sync,
                     );
                 }
-                let status =
-                    Status::unknown(format!("Exception raised during handler execution: {e}"));
+                let status = Status::unknown(e.to_string());
                 for tx in response_txs {
                     let _ = tx.send(Err(status.clone())).await;
                 }

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/chalk-remote-call-server/src/metrics.rs

@@ -1,6 +1,6 @@
-//! Metrics emission for the self-consuming shim, mirroring the catalog
-//! consumer / fnq-server: build a `chalk_metrics` publishing pipeline at startup
-//! and emit per-call dequeue + processing-latency metrics.
+//! Function-call metrics for synchronous gRPC calls and self-consumed queue work.
+//! A shared `chalk_metrics` publishing pipeline emits call counts and
+//! processing latency, independently of whether Redis queue consumption is enabled.
 //!
 //! The External Function "Function Calls Dequeued" chart reads TimescaleDB
 //! `metrics1`, which is fed only by the chalk_metrics PubSub bus (statsd goes to
@@ -15,8 +15,9 @@ use chalk_metrics::metrics::well_known_metrics::WellKnownMetricName;
 use chalk_metrics::{
     make_pubsub_publisher, BatchConfig, BusPublisher, MetricsPipeline, PublishingMetricsPipeline,
 };
+use chalk_statsd::datadog::DatadogError;
 use chalk_statsd::metrics::MetricsClient;
-use tracing::{info, warn};
+use tracing::{debug, warn};
 
 // Batch tuning — chalk_function_queue's defaults (METRICS_BATCH_* ), inlined.
 const BATCH_MAX_MESSAGES: usize = 1000;
@@ -24,26 +25,27 @@ const BATCH_MAX_BYTES: usize = 10 * 1024 * 1024; // 10 MB
 const BATCH_MAX_LATENCY: Duration = Duration::from_millis(100);
 
 /// Build and start the metrics pipeline from the environment, mirroring the
-/// fnq-server / catalog-consumer init. Returns `None` only if the pipeline
-/// object can't be constructed; the self-consumer then runs without metrics.
+/// fnq-server / catalog-consumer init. Returns `None` if startup fails.
 ///
 /// The bus publisher is what reaches the metrics store (and thus the dashboard);
-/// statsd alone only reaches Datadog. An empty `METRICS_BUS_TOPIC` therefore
-/// means the dashboard won't move — surfaced as a warning, not an error.
+/// StatsD and the bus are optional sinks. Missing configuration is quiet;
+/// failures initializing a configured sink remain warnings.
 pub async fn init_pipeline() -> Option<Arc<PublishingMetricsPipeline>> {
     let environment_id = std::env::var("CHALK_ENVIRONMENT_ID").unwrap_or_default();
 
     let statsd = Arc::new(
         MetricsClient::new_from_default_environment().unwrap_or_else(|e| {
-            warn!(error = %e, "failed to init statsd client; statsd metrics disabled");
+            if !matches!(
+                e.downcast_ref::<DatadogError>(),
+                Some(DatadogError::ConnectionInfoNotFound)
+            ) {
+                warn!(error = %e, "failed to init statsd client; statsd metrics disabled");
+            }
             MetricsClient::new_null()
         }),
     );
 
     let publishers: Vec<Arc<dyn BusPublisher>> = build_bus_publisher().await.into_iter().collect();
-    if publishers.is_empty() {
-        warn!("no metrics bus publisher configured; function call metrics will not reach the dashboard");
-    }
 
     let metrics_pipeline: Arc<PublishingMetricsPipeline> =
         Arc::new(PublishingMetricsPipeline::new_with_env_var_defaults(
@@ -54,8 +56,9 @@ pub async fn init_pipeline() -> Option<Arc<PublishingMetricsPipeline>> {
         ));
     if let Err(e) = metrics_pipeline.start().await {
         warn!(error = %e, "failed to start metrics pipeline; metrics disabled");
+        return None;
     }
-    info!("fnq self-consumer metrics pipeline started");
+    debug!("function-call metrics pipeline started");
     Some(metrics_pipeline)
 }
 

{chalk_remote_call_python-1.9.0 → chalk_remote_call_python-1.9.2}/chalk-remote-call-rs/chalk-remote-call-server/src/python_bridge.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 
+use chalk_remote_call_proto::chalk::common::v1::{ChalkError, ChalkException};
 use chalk_remote_call_proto::chalk::runtime::v1::CallFunctionResponse;
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyList};
@@ -321,28 +322,62 @@ fn invoke_process_fn(
 #[derive(Debug)]
 pub struct PythonError {
     details: String,
+    wire_message: String,
 }
 
 impl PythonError {
     fn new(message: String) -> Self {
-        Self { details: message }
+        Self {
+            details: message.clone(),
+            wire_message: message,
+        }
     }
 
     pub fn details(&self) -> &str {
         &self.details
     }
+
+    pub fn chalk_error(&self) -> ChalkError {
+        let exception = serde_json::from_str::<serde_json::Value>(&self.wire_message)
+            .ok()
+            .and_then(|payload| {
+                let exception = payload.get("exception")?;
+                Some(ChalkException {
+                    kind: exception.get("kind")?.as_str()?.to_string(),
+                    message: exception.get("message")?.as_str()?.to_string(),
+                    stacktrace: exception.get("stacktrace")?.as_str()?.to_string(),
+                    internal_stacktrace: exception
+                        .get("internal_stacktrace")?
+                        .as_str()?
+                        .to_string(),
+                })
+            });
+        ChalkError {
+            message: self.wire_message.clone(),
+            exception,
+            ..Default::default()
+        }
+    }
 }
 
 impl std::fmt::Display for PythonError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.details)
+        write!(f, "{}", self.wire_message)
     }
 }
 
 fn into_python_error(py: Python<'_>, err: PyErr) -> PythonError {
     let summary = err.to_string();
     let details = format_python_traceback(py, &err).unwrap_or_else(|_| summary.clone());
-    PythonError { details }
+    let wire_message = py
+        .import("chalk_remote_call.errors")
+        .and_then(|module| module.call_method1("serialize_exception", (err.value(py),)))
+        .and_then(|value| value.extract::<String>())
+        .unwrap_or_else(|_| details.clone());
+    PythonError {
+        details,
+        wire_message,
+    }
 }
 
 fn format_python_traceback(py: Python<'_>, err: &PyErr) -> PyResult<String> {