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

{chalk_remote_call_python-1.9.2/chalk_remote_call_python.egg-info → chalk_remote_call_python-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.9.2
+Version: 1.10.1
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -110,8 +110,11 @@ python -m chalk_remote_call --handler my_handler.handler
 
 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.
+`exception.stacktrace` field, which the log collector uses for the traceback.
+CLI logging is configured before importing runtime dependencies. Import failures,
+invalid environment configuration, and exceptions escaping startup or the server
+emit a single ERROR record with the full traceback and exit with status 1.
+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

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

@@ -72,8 +72,11 @@ python -m chalk_remote_call --handler my_handler.handler
 
 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.
+`exception.stacktrace` field, which the log collector uses for the traceback.
+CLI logging is configured before importing runtime dependencies. Import failures,
+invalid environment configuration, and exceptions escaping startup or the server
+emit a single ERROR record with the full traceback and exit with status 1.
+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

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

@@ -511,7 +511,7 @@ dependencies = [
 [[package]]
 name = "chalk-queue"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=9c61f6a938d8f885f138217ac64149e29d7a691e#9c61f6a938d8f885f138217ac64149e29d7a691e"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=41458754e6916245a092ddc09562bcaf4dea373e#41458754e6916245a092ddc09562bcaf4dea373e"
 dependencies = [
  "base64 0.22.1",
  "redis",

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

@@ -37,6 +37,6 @@ futures-util = "0.3"
 # `[patch.crates-io]` here it builds against vanilla crates.io redis (it only
 # 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 = "9c61f6a938d8f885f138217ac64149e29d7a691e" }
+chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "41458754e6916245a092ddc09562bcaf4dea373e" }
 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.2 → chalk_remote_call_python-1.10.1}/chalk-remote-call-rs/chalk-remote-call-server/src/self_consumer.rs

@@ -102,6 +102,136 @@ const STREAM_RECLAIM_INTERVAL: Duration = Duration::from_secs(10);
 /// inbound network peer on this path.
 const PEER: &str = "fnq-self-consumer";
 
+/// Selects where a queued call publishes its result without allowing a shared
+/// batch stream to lose the call identity needed by the collector.
+#[derive(Debug, PartialEq, Eq)]
+enum ResultDestination {
+    PerCall {
+        stream_key: String,
+        result_ttl: Duration,
+    },
+    Batch {
+        stream_key: String,
+        call_id: String,
+        row_index: u64,
+    },
+}
+
+impl ResultDestination {
+    fn for_call(queue: &FunctionQueue, work: &QueuedCall, call_uuid: Uuid) -> Self {
+        let batch = work.batch_result.as_ref().map(|batch_result| {
+            (
+                queue.batch_stream_key_for(&batch_result.batch_id),
+                work.call_id.clone(),
+                batch_result.row_index,
+            )
+        });
+        Self::from_routing(
+            queue.stream_key_for(call_uuid),
+            Duration::from_secs(work.result_ttl_seconds),
+            batch,
+        )
+    }
+
+    fn from_routing(
+        per_call_stream_key: String,
+        result_ttl: Duration,
+        batch: Option<(String, String, u64)>,
+    ) -> Self {
+        match batch {
+            Some((stream_key, call_id, row_index)) => Self::Batch {
+                stream_key,
+                call_id,
+                row_index,
+            },
+            None => Self::PerCall {
+                stream_key: per_call_stream_key,
+                result_ttl,
+            },
+        }
+    }
+
+    async fn write_chunk(
+        &self,
+        conn: &mut ConnectionManager,
+        seq: u64,
+        data: &[u8],
+    ) -> Result<(), redis::RedisError> {
+        match self {
+            Self::PerCall { stream_key, .. } => {
+                stream_writer::write_chunk(conn, stream_key, seq, data).await
+            }
+            Self::Batch {
+                stream_key,
+                call_id,
+                row_index,
+            } => {
+                stream_writer::BatchStreamWriter::new(stream_key, call_id, *row_index)
+                    .write_chunk(conn, seq, data)
+                    .await
+            }
+        }
+    }
+
+    async fn write_end(
+        &self,
+        conn: &mut ConnectionManager,
+        seq: u64,
+    ) -> Result<(), redis::RedisError> {
+        match self {
+            Self::PerCall {
+                stream_key,
+                result_ttl,
+            } => stream_writer::write_end_with_ttl(conn, stream_key, seq, *result_ttl).await,
+            Self::Batch {
+                stream_key,
+                call_id,
+                row_index,
+            } => {
+                stream_writer::BatchStreamWriter::new(stream_key, call_id, *row_index)
+                    .write_end(conn, seq)
+                    .await
+            }
+        }
+    }
+
+    async fn write_error(
+        &self,
+        conn: &mut ConnectionManager,
+        seq: u64,
+        exc_type: &str,
+        message: &str,
+        traceback: Option<&str>,
+    ) -> Result<(), redis::RedisError> {
+        match self {
+            Self::PerCall {
+                stream_key,
+                result_ttl,
+            } => {
+                stream_writer::write_error_with_ttl(
+                    conn,
+                    stream_key,
+                    seq,
+                    exc_type,
+                    message,
+                    traceback,
+                    *result_ttl,
+                )
+                .await
+            }
+            Self::Batch {
+                stream_key,
+                call_id,
+                row_index,
+            } => {
+                stream_writer::BatchStreamWriter::new(stream_key, call_id, *row_index)
+                    .write_error(conn, seq, exc_type, message, traceback)
+                    .await
+            }
+        }
+    }
+}
+
 /// Configuration for the self-consumer, read from the environment.
 ///
 /// [`from_env`](Self::from_env) returns `None` when `CHALK_FNQ_REDIS_URL` is
@@ -577,7 +707,7 @@ async fn run_one_call(
     {
         Ok(Ok(())) => true,
         Ok(Err(e)) => {
-            // The call's result stream may be incomplete; the call's 24h stream TTL
+            // The call's result stream may be incomplete; the enqueue safety TTL
             // and the meta status are the backstop for a stuck poller.
             error!(call_id = %call_id, error = %e, "failed to execute/write queued call");
             false
@@ -663,8 +793,8 @@ async fn run_one_coalesced_call(
     {
         Ok(()) => true,
         Err(e) => {
-            // The call's result stream may be incomplete; the 24h stream TTL and
-            // the meta status are the backstop for a stuck poller.
+            // The call's result stream may be incomplete; the enqueue safety TTL
+            // and the meta status are the backstop for a stuck poller.
             error!(call_id = %call_id, error = %e, "failed to execute/write coalesced queued call");
             false
         }
@@ -694,7 +824,7 @@ async fn coalesced_execute_and_write(
     metrics_pipeline: Option<&Arc<PublishingMetricsPipeline>>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let call_uuid = Uuid::parse_str(&work.call_id)?;
-    let stream_key = queue.stream_key_for(call_uuid);
+    let result_destination = ResultDestination::for_call(queue, &work, call_uuid);
     let ipc_bytes = work.call.feather_bytes()?;
     let function_name = work.call.name.clone();
     let mut metadata = work.metadata.otel_headers.clone();
@@ -736,8 +866,10 @@ async fn coalesced_execute_and_write(
 
     match response {
         Some(Ok(resp)) => {
-            stream_writer::write_chunk(conn, &stream_key, 1, &resp.feather_stream).await?;
-            stream_writer::write_end(conn, &stream_key, 2).await?;
+            result_destination
+                .write_chunk(conn, 1, &resp.feather_stream)
+                .await?;
+            result_destination.write_end(conn, 2).await?;
             let _ = queue
                 .complete_status(
                     call_uuid,
@@ -751,15 +883,9 @@ async fn coalesced_execute_and_write(
         Some(Err(status)) => {
             // Parity with the enqueue/poll path: only a message string is
             // available, so exc_type is a fixed placeholder.
-            stream_writer::write_error(
-                conn,
-                &stream_key,
-                1,
-                "RemoteFunctionError",
-                status.message(),
-                None,
-            )
-            .await?;
+            result_destination
+                .write_error(conn, 1, "RemoteFunctionError", status.message(), None)
+                .await?;
             let summary: String = status.message().chars().take(200).collect();
             let _ = queue
                 .complete_status(call_uuid, "failed", &summary, Some(processing_trace_id))
@@ -771,7 +897,8 @@ async fn coalesced_execute_and_write(
             // happen (it always sends one Ok/Err per caller), but treat a
             // missing response as a failure rather than leaving the poller hung.
             let msg = "coalesced dispatch produced no response";
-            stream_writer::write_error(conn, &stream_key, 1, "RemoteFunctionError", msg, None)
+            result_destination
+                .write_error(conn, 1, "RemoteFunctionError", msg, None)
                 .await?;
             let _ = queue
                 .complete_status(call_uuid, "failed", msg, Some(processing_trace_id))
@@ -810,7 +937,7 @@ async fn execute_and_write(
     metrics_pipeline: Option<&Arc<PublishingMetricsPipeline>>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let call_uuid = Uuid::parse_str(&work.call_id)?;
-    let stream_key = queue.stream_key_for(call_uuid);
+    let result_destination = ResultDestination::for_call(queue, &work, call_uuid);
     let ipc_bytes = work.call.feather_bytes()?;
     let function_name = work.call.name.clone();
     let mut metadata = work.metadata.otel_headers.clone();
@@ -857,7 +984,7 @@ async fn execute_and_write(
             biased;
             res = &mut handler_fut => break res,
             _ = tokio::time::timeout(flush_timeout, notify_handle.notified()) => {
-                if let Err(e) = flush_new(conn, &stream_key, &buffer, &mut flushed, &mut seq).await {
+                if let Err(e) = flush_new(conn, &result_destination, &buffer, &mut flushed, &mut seq).await {
                     // Non-fatal: keep draining; the cursor didn't advance past the
                     // failed chunk, so the next wait retries it without duplicating.
                     warn!(call_id = %work.call_id, error = %e, "failed to flush partial results; retrying");
@@ -883,13 +1010,13 @@ async fn execute_and_write(
     // this is everything). This happens even if the handler panicked mid-execution,
     // so partial output is always preserved. Parity with the enqueue/poll path: a
     // generator that yields then raises surfaces its chunks followed by the error.
-    if let Err(e) = flush_new(conn, &stream_key, &buffer, &mut flushed, &mut seq).await {
+    if let Err(e) = flush_new(conn, &result_destination, &buffer, &mut flushed, &mut seq).await {
         warn!(call_id = %work.call_id, error = %e, "failed to flush final chunks");
     }
 
     match result {
         Ok(()) => {
-            stream_writer::write_end(conn, &stream_key, seq).await?;
+            result_destination.write_end(conn, seq).await?;
             let _ = queue
                 .complete_status(
                     call_uuid,
@@ -901,15 +1028,15 @@ async fn execute_and_write(
             info!(call_id = %work.call_id, chunks = flushed, "queued call completed");
         }
         Err(e) => {
-            stream_writer::write_error(
-                conn,
-                &stream_key,
-                seq,
-                "RemoteFunctionError",
-                &e.to_string(),
-                Some(e.details()),
-            )
-            .await?;
+            result_destination
+                .write_error(
+                    conn,
+                    seq,
+                    "RemoteFunctionError",
+                    &e.to_string(),
+                    Some(e.details()),
+                )
+                .await?;
             let summary: String = e.to_string().chars().take(200).collect();
             let _ = queue
                 .complete_status(call_uuid, "failed", &summary, Some(processing_trace_id))
@@ -932,7 +1059,7 @@ async fn execute_and_write(
 /// failed chunk, so a retry re-sends only the unwritten tail (no gaps, no dupes).
 async fn flush_new(
     conn: &mut ConnectionManager,
-    stream_key: &str,
+    result_destination: &ResultDestination,
     buffer: &Arc<Mutex<ChunkBuffer>>,
     flushed: &mut usize,
     seq: &mut u64,
@@ -947,7 +1074,7 @@ async fn flush_new(
             .collect()
     };
     for chunk in &new {
-        stream_writer::write_chunk(conn, stream_key, *seq, chunk).await?;
+        result_destination.write_chunk(conn, *seq, chunk).await?;
         *seq += 1;
         *flushed += 1;
     }
@@ -1022,6 +1149,41 @@ mod tests {
         assert_eq!(DEFAULT_FLUSH_TIMEOUT_MS, 100);
     }
 
+    #[test]
+    fn result_destination_preserves_per_call_stream() {
+        assert_eq!(
+            ResultDestination::from_routing(
+                "tenant:gen:call-1:stream".to_string(),
+                Duration::from_secs(60),
+                None,
+            ),
+            ResultDestination::PerCall {
+                stream_key: "tenant:gen:call-1:stream".to_string(),
+                result_ttl: Duration::from_secs(60),
+            }
+        );
+    }
+
+    #[test]
+    fn result_destination_routes_batch_call_with_correlation() {
+        assert_eq!(
+            ResultDestination::from_routing(
+                "unused-per-call-stream".to_string(),
+                Duration::from_secs(60),
+                Some((
+                    "tenant:batch:batch-1:results".to_string(),
+                    "call-1".to_string(),
+                    42,
+                )),
+            ),
+            ResultDestination::Batch {
+                stream_key: "tenant:batch:batch-1:results".to_string(),
+                call_id: "call-1".to_string(),
+                row_index: 42,
+            }
+        );
+    }
+
     #[test]
     fn test_config_from_env_returns_none_when_redis_url_unset() {
         let _env = lock_env();
@@ -1043,6 +1205,7 @@ mod tests {
         std::env::remove_var(ENV_FLUSH_TIMEOUT_MS);
         std::env::remove_var(ENV_QUEUE_PROTOCOL);
         std::env::remove_var(ENV_STREAM_READ_COUNT);
+        std::env::remove_var(ENV_MAX_CONCURRENT);
 
         let config = SelfConsumerConfig::from_env().expect("config should parse");
         assert_eq!(config.sem_ttl, Duration::from_secs(DEFAULT_SEM_TTL_SECS));

chalk_remote_call_python-1.10.1/chalk_remote_call/_version.py

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

{chalk_remote_call_python-1.9.2 → chalk_remote_call_python-1.10.1}/chalk_remote_call/cli.py

@@ -6,7 +6,6 @@ import os
 import sys
 
 from chalk_remote_call.handler_loader import load_function, load_handler
-from chalk_remote_call.input_transform import parse_input_args
 from chalk_remote_call.logging import JsonFormatter
 from chalk_remote_call.server import serve
 
@@ -23,6 +22,17 @@ def _env_int(name: str) -> int | None:
 
 
 def main() -> None:
+    log_handler = logging.StreamHandler(sys.stderr)
+    log_handler.setFormatter(JsonFormatter())
+    logging.basicConfig(level=logging.INFO, handlers=[log_handler], force=True)
+    try:
+        _run()
+    except Exception:
+        logging.getLogger(__name__).exception("Remote-call server failed")
+        sys.exit(1)
+
+
+def _run() -> None:
     parser = argparse.ArgumentParser(
         prog="chalk-remote-call",
         description="Start a gRPC server implementing the Chalk RemoteCallService.",
@@ -100,9 +110,9 @@ def main() -> None:
     )
     args = parser.parse_args()
 
-    log_handler = logging.StreamHandler(sys.stderr)
-    log_handler.setFormatter(JsonFormatter())
-    logging.basicConfig(level=getattr(logging, args.log_level), handlers=[log_handler])
+    logging.getLogger().setLevel(args.log_level)
+
+    from chalk_remote_call.input_transform import parse_input_args
 
     # Load handler
     try:

{chalk_remote_call_python-1.9.2 → chalk_remote_call_python-1.10.1}/chalk_remote_call/server.py

@@ -5,13 +5,6 @@ import os
 from collections.abc import Callable
 from typing import Any, Literal
 
-from chalk_remote_call._native import start_server
-from chalk_remote_call.servicer import (
-    process_batches,
-    process_batches_coalesced,
-    process_batches_coalesced_combined,
-)
-
 logger = logging.getLogger(__name__)
 
 _BATCHING_MODE_ENV = "CHALK_REMOTE_CALL_BATCHING_MODE"
@@ -75,6 +68,14 @@ def serve(
             CHALK_REMOTE_CALL_BATCHING_MODE env var when set; otherwise the
             env var (or "per_caller") wins.
     """
+    # Keep package imports lightweight so the CLI can configure logging before dependency failures.
+    from chalk_remote_call._native import start_server
+    from chalk_remote_call.servicer import (
+        process_batches,
+        process_batches_coalesced,
+        process_batches_coalesced_combined,
+    )
+
     if on_startup is not None:
         logger.info("Running startup hook...")
         on_startup()

{chalk_remote_call_python-1.9.2 → chalk_remote_call_python-1.10.1/chalk_remote_call_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.9.2
+Version: 1.10.1
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -110,8 +110,11 @@ python -m chalk_remote_call --handler my_handler.handler
 
 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.
+`exception.stacktrace` field, which the log collector uses for the traceback.
+CLI logging is configured before importing runtime dependencies. Import failures,
+invalid environment configuration, and exceptions escaping startup or the server
+emit a single ERROR record with the full traceback and exit with status 1.
+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

chalk_remote_call_python-1.9.2/chalk_remote_call/_version.py

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