chalk-remote-call-python 1.10.10__tar.gz → 1.10.12__tar.gz

{chalk_remote_call_python-1.10.10/chalk_remote_call_python.egg-info → chalk_remote_call_python-1.10.12}/PKG-INFO

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

{chalk_remote_call_python-1.10.10 → chalk_remote_call_python-1.10.12}/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=1460144ea659debbaee9dccadcd4d7dbf383ccf8#1460144ea659debbaee9dccadcd4d7dbf383ccf8"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=6156b025245e28f409bd6c115cfa158ed60203ea#6156b025245e28f409bd6c115cfa158ed60203ea"
 dependencies = [
  "base64 0.22.1",
  "redis",

{chalk_remote_call_python-1.10.10 → chalk_remote_call_python-1.10.12}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -45,7 +45,7 @@ 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 = "1460144ea659debbaee9dccadcd4d7dbf383ccf8" }
+chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "6156b025245e28f409bd6c115cfa158ed60203ea" }
 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.10.10 → chalk_remote_call_python-1.10.12}/chalk-remote-call-rs/chalk-remote-call-server/src/metrics.rs

@@ -19,7 +19,7 @@ use chalk_statsd::metrics::MetricsClient;
 use tracing::{debug, warn};
 
 const DEQUEUED_METRIC: &str = "chalk.function_call.dequeued";
-const PROCESSING_LATENCY_METRIC: &str = "chalk.function_call.processing_latency";
+const CALL_DURATION_METRIC: &str = "chalk.function_call.call_duration";
 
 // Batch tuning — chalk_function_queue's defaults (METRICS_BATCH_* ), inlined.
 const BATCH_MAX_MESSAGES: usize = 1000;
@@ -220,7 +220,7 @@ pub fn record_completed_call(
     if let Some(statsd) = &metrics.statsd {
         let tags = call_tags(&function_name, success, mode);
         statsd.publish_count_eager(DEQUEUED_METRIC, 1, &tags);
-        statsd.publish_distribution_eager(PROCESSING_LATENCY_METRIC, elapsed_ms, &tags);
+        statsd.publish_distribution_eager(CALL_DURATION_METRIC, elapsed_ms, &tags);
     }
 
     if let Some(pipeline) = &metrics.pipeline {
@@ -302,7 +302,7 @@ mod tests {
     }
 
     #[test]
-    fn emits_count_and_latency_over_udp() {
+    fn emits_count_and_call_duration_over_udp() {
         let sink = UdpSocket::bind("127.0.0.1:0").unwrap();
         sink.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
         let metrics = CallMetrics {
@@ -325,13 +325,13 @@ mod tests {
 
         let mut seen = String::new();
         let mut buf = [0u8; 2048];
-        while !(seen.contains(DEQUEUED_METRIC) && seen.contains(PROCESSING_LATENCY_METRIC)) {
+        while !(seen.contains(DEQUEUED_METRIC) && seen.contains(CALL_DURATION_METRIC)) {
             let n = sink.recv(&mut buf).expect("statsd packet");
             seen.push_str(&String::from_utf8_lossy(&buf[..n]));
         }
         assert!(seen.contains("chalk.function_call.dequeued:1|c"), "{seen}");
         assert!(
-            seen.contains("chalk.function_call.processing_latency:250|d"),
+            seen.contains("chalk.function_call.call_duration:250|d"),
             "{seen}"
         );
         assert!(seen.contains("function_name:fn_a"), "{seen}");
@@ -340,6 +340,93 @@ mod tests {
         assert!(seen.contains("kind:function"), "{seen}");
     }
 
+    #[tokio::test]
+    async fn measures_real_python_handler_duration_over_udp() {
+        use crate::python_bridge::{ChunkBuffer, PythonHandler};
+        use pyo3::prelude::*;
+
+        Python::initialize();
+        let handler = Python::attach(|py| {
+            Arc::new(PythonHandler::new(
+                py.eval(
+                    pyo3::ffi::c_str!("lambda: __import__('time').sleep(0.06)"),
+                    None,
+                    None,
+                )
+                .unwrap()
+                .unbind(),
+                py.eval(
+                    pyo3::ffi::c_str!(
+                        "lambda data, handler, args, context, emit: (handler(), emit(b'result'))"
+                    ),
+                    None,
+                    None,
+                )
+                .unwrap()
+                .unbind(),
+                None,
+            ))
+        });
+        let sink = UdpSocket::bind("127.0.0.1:0").unwrap();
+        sink.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+        let metrics = CallMetrics {
+            statsd: Some(Arc::new(
+                MetricsClient::new_from_datadog_config_unbatched(DatadogConnection::UdpSocket(
+                    sink.local_addr().unwrap().to_string(),
+                ))
+                .unwrap(),
+            )),
+            pipeline: None,
+        };
+
+        let started = std::time::Instant::now();
+        let result = handler
+            .call_into_buffer(
+                vec![1],
+                "real_handler".to_string(),
+                HashMap::new(),
+                String::new(),
+                ChunkBuffer::new().into_shared(),
+            )
+            .await;
+        let elapsed = started.elapsed();
+        assert!(result.is_ok(), "handler failed: {result:?}");
+        record_completed_call(&metrics, "real_handler", true, elapsed, Mode::Async);
+
+        let mut packets = Vec::new();
+        let mut buf = [0u8; 2048];
+        while packets.len() < 2 {
+            let n = sink.recv(&mut buf).expect("StatsD packet");
+            packets.push(String::from_utf8_lossy(&buf[..n]).to_string());
+        }
+        let distribution_value = |name: &str| -> f64 {
+            let packet = packets
+                .iter()
+                .find(|packet| packet.starts_with(name))
+                .unwrap_or_else(|| panic!("missing {name}: {packets:?}"));
+            let value = packet
+                .strip_prefix(name)
+                .unwrap()
+                .split('|')
+                .next()
+                .unwrap()
+                .parse::<f64>()
+                .unwrap();
+            assert!(packet.contains("|d"), "expected distribution: {packet}");
+            value
+        };
+        let call_duration = distribution_value("chalk.function_call.call_duration:");
+        assert!(
+            call_duration >= 50.0,
+            "60 ms handler sleep yielded {call_duration} ms call duration"
+        );
+        assert!(
+            (call_duration - elapsed.as_secs_f64() * 1000.0).abs() < 1.0,
+            "emitted {call_duration} ms, measured {elapsed:?}"
+        );
+        println!("60 ms Python handler sleep yielded {call_duration:.2} ms call duration");
+    }
+
     fn call_metrics(pipeline: &Arc<PublishingMetricsPipeline>) -> Arc<CallMetrics> {
         Arc::new(CallMetrics {
             statsd: None,

{chalk_remote_call_python-1.10.10 → chalk_remote_call_python-1.10.12}/chalk-remote-call-rs/chalk-remote-call-server/src/self_consumer.rs

@@ -42,7 +42,7 @@ use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use chalk_queue::semaphore::renew_many;
+use chalk_queue::semaphore::{release_many, renew_many};
 use chalk_queue::stream_writer;
 use chalk_queue::types::{DeliveryAttempt, QueuedCall};
 use chalk_queue::{
@@ -802,7 +802,7 @@ async fn run_stream_dispatch_loop(
     input_queue: BoundFunctionQueue,
     legacy_queue: Option<BoundFunctionQueue>,
     sem: chalk_queue::DistributedSemaphore,
-    conn: ConnectionManager,
+    mut conn: ConnectionManager,
     consumer_name: String,
     live_calls: LiveCalls,
     handler: Arc<PythonHandler>,
@@ -877,23 +877,23 @@ async fn run_stream_dispatch_loop(
             }
         }
 
+        // Return unused reservations in one round-trip before dispatching work.
+        // Transferring the tokens prevents Drop from also releasing each lease.
+        let used = deliveries.len().min(leases.len());
+        let unused_tokens = leases
+            .split_off(used)
+            .into_iter()
+            .map(SemaphoreLease::into_token)
+            .collect::<Vec<_>>();
+        let _ = release_many(&mut conn, sem.key(), &unused_tokens).await;
+
         if deliveries.is_empty() {
-            for lease in leases {
-                let _ = lease.release().await;
-            }
             tokio::time::sleep(backoff).await;
             backoff = (backoff * 2).min(config.poll_backoff_max);
             continue;
         }
 
         backoff = config.poll_backoff_initial;
-        // `dequeue_many` can return fewer records than requested. Only retain
-        // one lease per record and immediately return the unneeded capacity.
-        let used = deliveries.len().min(leases.len());
-        let unused = leases.split_off(used);
-        for lease in unused {
-            let _ = lease.release().await;
-        }
         for (delivery, lease) in deliveries.into_iter().zip(leases) {
             dispatch_delivery(
                 queue.clone(),

chalk_remote_call_python-1.10.12/chalk_remote_call/_version.py

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

{chalk_remote_call_python-1.10.10 → chalk_remote_call_python-1.10.12/chalk_remote_call_python.egg-info}/PKG-INFO

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

chalk_remote_call_python-1.10.10/chalk_remote_call/_version.py

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