chalk-remote-call-python 1.5.0__tar.gz → 1.6.0__tar.gz

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.5.0
+Version: 1.6.0
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Typing :: Typed
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -18,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: pyarrow>=14.0.0
 Provides-Extra: dev

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk-remote-call-rs/Cargo.lock

@@ -1066,11 +1066,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219"
+checksum = "37a6df7eab65fc7bee654a421404947e10a0f7085b6951bf2ea395f4659fb0cf"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -1084,19 +1083,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999"
+checksum = "f77d387774f6f6eec64a004eac0ed525aab7fa1966d94b42f743797b3e395afb"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33"
+checksum = "2dd13844a4242793e02df3e2ec093f540d948299a6a77ea9ce7afd8623f542be"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1104,9 +1102,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9"
+checksum = "eaf8f9f1108270b90d3676b8679586385430e5c0bb78bb5f043f95499c821a71"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1116,9 +1114,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a"
+checksum = "70a3b2274450ba5288bc9b8c1b69ff569d1d61189d4bff38f8d22e03d17f932b"
 dependencies = [
  "heck",
  "proc-macro2",

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -9,7 +9,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 chalk-remote-call-proto = { path = "../chalk-remote-call-proto" }
-pyo3 = { version = "0.24", features = ["extension-module"] }
+pyo3 = { version = "0.27", features = ["extension-module"] }
 tonic = "0.12"
 tonic-health = "0.12"
 tonic-reflection = "0.12"

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk-remote-call-rs/chalk-remote-call-server/src/lib.rs

@@ -54,7 +54,7 @@ fn start_server(
     };
 
     // Release the GIL while the Rust server runs
-    py.allow_threads(|| {
+    py.detach(|| {
         let rt = tokio::runtime::Builder::new_multi_thread()
             .worker_threads(workers)
             .enable_all()

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk-remote-call-rs/chalk-remote-call-server/src/python_bridge.rs

@@ -15,11 +15,12 @@ pub struct PythonHandler {
     arg_names: Option<Vec<String>>,
 }
 
-/// One caller's input: request bytes + gRPC metadata + peer address.
+/// One caller's input: request bytes + function name + gRPC metadata + peer address.
 /// Used identically in both the single-request and coalesced paths; the
 /// coalesced path just has N of them.
 pub struct CallerInput {
     pub ipc_bytes: Vec<u8>,
+    pub function_name: String,
     pub metadata: HashMap<String, String>,
     pub peer: String,
 }
@@ -40,17 +41,20 @@ impl PythonHandler {
     pub async fn call(
         &self,
         ipc_bytes: Vec<u8>,
+        function_name: String,
         metadata: HashMap<String, String>,
         peer: String,
     ) -> Result<Vec<Vec<u8>>, PythonError> {
         let (handler, process_fn) =
-            Python::with_gil(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
+            Python::attach(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
         let arg_names = self.arg_names.clone();
 
         tokio::task::spawn_blocking(move || {
-            Python::with_gil(|py| -> Result<Vec<Vec<u8>>, PythonError> {
+            Python::attach(|py| -> Result<Vec<Vec<u8>>, PythonError> {
                 let py_bytes = PyBytes::new(py, &ipc_bytes).into_any().unbind();
-                let py_ctx = build_context(py, &metadata, &peer)?.into_any().unbind();
+                let py_ctx = build_context(py, &function_name, &metadata, &peer)?
+                    .into_any()
+                    .unbind();
                 let py_arg_names = build_arg_names(py, arg_names.as_deref())?;
                 invoke_process_fn(py, &process_fn, &handler, py_bytes, py_arg_names, py_ctx)
             })
@@ -67,11 +71,11 @@ impl PythonHandler {
         callers: Vec<CallerInput>,
     ) -> Result<Vec<Vec<u8>>, PythonError> {
         let (handler, process_fn) =
-            Python::with_gil(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
+            Python::attach(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
         let arg_names = self.arg_names.clone();
 
         tokio::task::spawn_blocking(move || {
-            Python::with_gil(|py| -> Result<Vec<Vec<u8>>, PythonError> {
+            Python::attach(|py| -> Result<Vec<Vec<u8>>, PythonError> {
                 let py_inputs = PyList::empty(py);
                 let py_contexts = PyList::empty(py);
                 for c in &callers {
@@ -79,7 +83,7 @@ impl PythonHandler {
                         .append(PyBytes::new(py, &c.ipc_bytes))
                         .map_err(|e| into_python_error(py, e))?;
                     py_contexts
-                        .append(build_context(py, &c.metadata, &c.peer)?)
+                        .append(build_context(py, &c.function_name, &c.metadata, &c.peer)?)
                         .map_err(|e| into_python_error(py, e))?;
                 }
                 let py_arg_names = build_arg_names(py, arg_names.as_deref())?;
@@ -100,9 +104,10 @@ impl PythonHandler {
 
 // ---- Shared helpers -------------------------------------------------------
 
-/// Build a `{"peer": str, "metadata": dict}` context dict for one caller.
+/// Build a `{"function_name": str, "peer": str, "metadata": dict}` context dict for one caller.
 fn build_context<'py>(
     py: Python<'py>,
+    function_name: &str,
     metadata: &HashMap<String, String>,
     peer: &str,
 ) -> Result<Bound<'py, PyDict>, PythonError> {
@@ -113,6 +118,8 @@ fn build_context<'py>(
             .map_err(|e| into_python_error(py, e))?;
     }
     let ctx = PyDict::new(py);
+    ctx.set_item("function_name", function_name)
+        .map_err(|e| into_python_error(py, e))?;
     ctx.set_item("peer", peer)
         .map_err(|e| into_python_error(py, e))?;
     ctx.set_item("metadata", meta_dict)
@@ -152,13 +159,14 @@ fn invoke_process_fn(
         .map_err(|e| into_python_error(py, e))?;
 
     let result_list: &Bound<'_, PyList> = result
-        .downcast_bound::<PyList>(py)
+        .bind(py)
+        .cast::<PyList>()
         .map_err(|e| PythonError(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
-            .downcast::<PyBytes>()
+            .cast::<PyBytes>()
             .map_err(|e| PythonError(format!("bridge must return list[bytes], got item: {e}")))?;
         out.push(bytes_ref.as_bytes().to_vec());
     }

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk-remote-call-rs/chalk-remote-call-server/src/service.rs

@@ -40,7 +40,11 @@ impl RemoteCallService for RemoteCallServiceImpl {
 
         // Accumulate all feather_stream bytes from the request stream
         let mut all_bytes: Vec<u8> = Vec::new();
+        let mut function_name = String::new();
         while let Some(req) = stream.message().await? {
+            if function_name.is_empty() && !req.name.is_empty() {
+                function_name = req.name.clone();
+            }
             all_bytes.extend_from_slice(&req.feather_stream);
             if all_bytes.len() > MAX_REQUEST_SIZE {
                 return Err(Status::resource_exhausted(format!(
@@ -74,6 +78,7 @@ impl RemoteCallService for RemoteCallServiceImpl {
                 .submit(BufferedCall {
                     input: CallerInput {
                         ipc_bytes: all_bytes,
+                        function_name,
                         metadata,
                         peer,
                     },
@@ -86,7 +91,7 @@ impl RemoteCallService for RemoteCallServiceImpl {
         // Single-request path.
         let handler = self.python_handler.clone();
         tokio::spawn(async move {
-            match handler.call(all_bytes, metadata, peer).await {
+            match handler.call(all_bytes, function_name, metadata, peer).await {
                 Ok(response_chunks) => {
                     for chunk in response_chunks {
                         let msg = CallFunctionResponse {

chalk_remote_call_python-1.6.0/chalk_remote_call/_version.py

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

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk_remote_call/servicer.py

@@ -10,6 +10,7 @@ import pyarrow as pa
 
 from chalk_remote_call.arrow_utils import decode_ipc_stream, encode_record_batch
 from chalk_remote_call.input_transform import transform
+from chalk_remote_call.tracing import remote_function_invocation_span
 
 
 def _is_structured(obj: Any) -> bool:
@@ -178,30 +179,31 @@ def process_batches(
         except Exception as e:
             raise ValueError(f"Input transformation failed: {e}") from e
 
-        try:
-            result = handler(event, context_metadata)
-            # If the handler is async, await the coroutine.
-            if inspect.iscoroutine(result):
-                result = _run_async(result)
-        except Exception as e:
-            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
-
-        try:
-            if inspect.isgenerator(result):
-                # Sync generator: encode each yielded value as a separate chunk.
-                for item in result:
-                    result_batch = _coerce_to_record_batch(item)
-                    results.append(encode_record_batch(result_batch))
-            elif inspect.isasyncgen(result):
-                # Async generator: collect items and encode each as a separate chunk.
-                for item in _collect_async_gen(result):
-                    result_batch = _coerce_to_record_batch(item)
+        with remote_function_invocation_span(context_metadata):
+            try:
+                result = handler(event, context_metadata)
+                # If the handler is async, await the coroutine.
+                if inspect.iscoroutine(result):
+                    result = _run_async(result)
+            except Exception as e:
+                raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+
+            try:
+                if inspect.isgenerator(result):
+                    # Sync generator: encode each yielded value as a separate chunk.
+                    for item in result:
+                        result_batch = _coerce_to_record_batch(item)
+                        results.append(encode_record_batch(result_batch))
+                elif inspect.isasyncgen(result):
+                    # Async generator: collect items and encode each as a separate chunk.
+                    for item in _collect_async_gen(result):
+                        result_batch = _coerce_to_record_batch(item)
+                        results.append(encode_record_batch(result_batch))
+                else:
+                    result_batch = _coerce_to_record_batch(result)
                     results.append(encode_record_batch(result_batch))
-            else:
-                result_batch = _coerce_to_record_batch(result)
-                results.append(encode_record_batch(result_batch))
-        except Exception as e:
-            raise RuntimeError(f"Failed to encode response: {e}") from e
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response: {e}") from e
 
     return results
 
@@ -273,26 +275,27 @@ def process_batches_coalesced(
 
     # Dispatch. Contexts are passed as a parallel list — handler can correlate
     # per-caller metadata with each event by index.
-    try:
-        result = handler(events, context_metadatas)
-        if inspect.iscoroutine(result):
-            result = _run_async(result)
-    except Exception as e:
-        raise RuntimeError(f"Exception raised during handler execution: {e}") from e
-
-    if not isinstance(result, list):
-        raise TypeError(f"Coalesced handler must return a list, got {type(result).__name__}")
-    if len(result) != len(events):
-        raise ValueError(f"Coalesced handler must return one result per input ({len(events)}); got {len(result)}")
-
-    # Coerce and encode each per-caller result.
-    output: list[bytes] = []
-    for i, item in enumerate(result):
+    with remote_function_invocation_span(context_metadatas, coalesced_count=len(context_metadatas)):
         try:
-            rb = _coerce_to_record_batch(item)
-            output.append(encode_record_batch(rb))
+            result = handler(events, context_metadatas)
+            if inspect.iscoroutine(result):
+                result = _run_async(result)
         except Exception as e:
-            raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
+            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+
+        if not isinstance(result, list):
+            raise TypeError(f"Coalesced handler must return a list, got {type(result).__name__}")
+        if len(result) != len(events):
+            raise ValueError(f"Coalesced handler must return one result per input ({len(events)}); got {len(result)}")
+
+        # Coerce and encode each per-caller result.
+        output: list[bytes] = []
+        for i, item in enumerate(result):
+            try:
+                rb = _coerce_to_record_batch(item)
+                output.append(encode_record_batch(rb))
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
 
     return output
 
@@ -375,34 +378,35 @@ def process_batches_coalesced_combined(
             )
         combined = combined.rename_columns(arg_names)
 
-    try:
-        result = handler(combined, offsets, context_metadatas)
-        if inspect.iscoroutine(result):
-            result = _run_async(result)
-    except Exception as e:
-        raise RuntimeError(f"Exception raised during handler execution: {e}") from e
-
-    if isinstance(result, pa.RecordBatch):
-        result_rb = result
-    else:
+    with remote_function_invocation_span(context_metadatas, coalesced_count=len(context_metadatas)):
         try:
-            result_rb = _coerce_to_record_batch(result)
+            result = handler(combined, offsets, context_metadatas)
+            if inspect.iscoroutine(result):
+                result = _run_async(result)
         except Exception as e:
-            raise RuntimeError(f"Failed to coerce handler output: {e}") from e
+            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
 
-    if result_rb.num_rows != combined.num_rows:
-        raise ValueError(
-            f"Combined handler must return a RecordBatch with {combined.num_rows} rows "
-            f"(matching input); got {result_rb.num_rows}"
-        )
+        if isinstance(result, pa.RecordBatch):
+            result_rb = result
+        else:
+            try:
+                result_rb = _coerce_to_record_batch(result)
+            except Exception as e:
+                raise RuntimeError(f"Failed to coerce handler output: {e}") from e
 
-    output: list[bytes] = []
-    for i in range(len(per_caller)):
-        start = offsets[i]
-        length = offsets[i + 1] - start
-        sliced = result_rb.slice(start, length)
-        try:
-            output.append(encode_record_batch(sliced))
-        except Exception as e:
-            raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
+        if result_rb.num_rows != combined.num_rows:
+            raise ValueError(
+                f"Combined handler must return a RecordBatch with {combined.num_rows} rows "
+                f"(matching input); got {result_rb.num_rows}"
+            )
+
+        output: list[bytes] = []
+        for i in range(len(per_caller)):
+            start = offsets[i]
+            length = offsets[i + 1] - start
+            sliced = result_rb.slice(start, length)
+            try:
+                output.append(encode_record_batch(sliced))
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
     return output

chalk_remote_call_python-1.6.0/chalk_remote_call/tracing.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import contextlib
+import importlib
+import os
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, cast
+
+_TRACER_NAME = "chalk_remote_call"
+_TRACE_CONTEXT_METADATA_KEYS = ("traceparent", "tracestate", "baggage")
+_REMOTE_FUNCTION_TRACE_POLICY_ENV_VAR = "CHALK_REMOTE_FUNCTION_TRACE_POLICY"
+_REMOTE_FUNCTION_TRACE_SAMPLE_RATE_ENV_VAR = "CHALK_REMOTE_FUNCTION_TRACE_SAMPLE_RATE"
+_TRACE_POLICY_PARENT_BASED_ALWAYS_OFF = "parentbased_always_off"
+_TRACE_POLICY_PARENT_BASED_TRACE_ID_RATIO = "parentbased_traceidratio"
+_TRACE_POLICY_ALWAYS_OFF = "always_off"
+_TRACE_POLICIES = frozenset(
+    {
+        _TRACE_POLICY_PARENT_BASED_ALWAYS_OFF,
+        _TRACE_POLICY_PARENT_BASED_TRACE_ID_RATIO,
+        _TRACE_POLICY_ALWAYS_OFF,
+    }
+)
+_missing_otel_modules = object()
+_missing_always_off_tracer = object()
+_otel_modules: tuple[Any, Any, Any] | object | None = None
+_always_off_tracer: Any | object | None = None
+_runtime_tracing_configured = False
+_runtime_tracer_provider: Any | None = None
+
+
+def _raw_metadata(context_metadata: Any) -> Mapping[str, Any] | None:
+    if not isinstance(context_metadata, Mapping):
+        return None
+
+    raw = context_metadata.get("metadata", context_metadata)
+    if isinstance(raw, Mapping):
+        return raw
+    return None
+
+
+def _collect_trace_metadata(
+    context_metadata: Any,
+) -> tuple[Mapping[str, Any] | None, Mapping[str, Any] | None]:
+    if isinstance(context_metadata, Mapping):
+        first = _raw_metadata(context_metadata)
+        if first is not None and first.get("traceparent"):
+            return first, first
+        return first, None
+
+    first: Mapping[str, Any] | None = None
+    if isinstance(context_metadata, Sequence) and not isinstance(context_metadata, str | bytes):
+        for item in context_metadata:
+            metadata = _raw_metadata(item)
+            if metadata is None:
+                continue
+
+            if first is None:
+                first = metadata
+            if metadata.get("traceparent"):
+                return first, metadata
+
+    return first, None
+
+
+def _trace_policy() -> str | None:
+    raw_policy = os.environ.get(_REMOTE_FUNCTION_TRACE_POLICY_ENV_VAR)
+    if raw_policy is None:
+        return None
+
+    policy = raw_policy.strip().lower()
+    if policy in _TRACE_POLICIES:
+        return policy
+    return None
+
+
+def _trace_sample_rate() -> float | None:
+    raw_rate = os.environ.get(_REMOTE_FUNCTION_TRACE_SAMPLE_RATE_ENV_VAR)
+    if raw_rate is None:
+        return None
+
+    try:
+        rate = float(raw_rate)
+    except ValueError:
+        return None
+
+    if rate < 0.0 or rate > 1.0:
+        return None
+    return rate
+
+
+def _otel_exporter_configured() -> bool:
+    return bool(os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT") or os.environ.get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"))
+
+
+def _configure_runtime_tracing(sample_rate: float) -> None:
+    global _runtime_tracing_configured, _runtime_tracer_provider
+    if _runtime_tracing_configured:
+        return
+
+    try:
+        resources = importlib.import_module("opentelemetry.sdk.resources")
+        sdk_trace = importlib.import_module("opentelemetry.sdk.trace")
+        sdk_sampling = importlib.import_module("opentelemetry.sdk.trace.sampling")
+        trace_api = importlib.import_module("opentelemetry.trace")
+    except Exception:
+        _runtime_tracing_configured = True
+        return
+
+    try:
+        provider = sdk_trace.TracerProvider(
+            resource=resources.Resource.create({"service.name": os.environ.get("CHALK_SERVICE") or _TRACER_NAME}),
+            sampler=sdk_sampling.ParentBased(sdk_sampling.TraceIdRatioBased(sample_rate)),
+        )
+
+        if _otel_exporter_configured():
+            try:
+                otlp_exporter = importlib.import_module("opentelemetry.exporter.otlp.proto.grpc.trace_exporter")
+                sdk_export = importlib.import_module("opentelemetry.sdk.trace.export")
+                provider.add_span_processor(sdk_export.BatchSpanProcessor(otlp_exporter.OTLPSpanExporter()))
+            except Exception:
+                pass
+
+        trace_api.set_tracer_provider(provider)
+        _runtime_tracer_provider = provider
+    except Exception:
+        pass
+    _runtime_tracing_configured = True
+
+
+def _span_metadata(
+    first_metadata: Mapping[str, Any] | None,
+    traceparent_metadata: Mapping[str, Any] | None,
+    policy: str,
+) -> tuple[Mapping[str, Any] | None, Any | None, Any]:
+    if traceparent_metadata is not None:
+        carrier = _trace_carrier(traceparent_metadata)
+        if not carrier:
+            return None, None, None
+
+        otel_modules = _get_otel_modules()
+        if otel_modules is None:
+            return None, None, None
+        _, propagate, trace = otel_modules
+
+        parent_context = propagate.extract(carrier)
+        parent_span_context = trace.get_current_span(parent_context).get_span_context()
+        if not parent_span_context.is_valid:
+            return None, None, None
+        return traceparent_metadata, parent_context, otel_modules
+
+    if policy != _TRACE_POLICY_PARENT_BASED_TRACE_ID_RATIO:
+        return None, None, None
+
+    sample_rate = _trace_sample_rate()
+    if sample_rate is None:
+        return None, None, None
+
+    _configure_runtime_tracing(sample_rate)
+    otel_modules = _get_otel_modules()
+    if otel_modules is None:
+        return None, None, None
+    return first_metadata, None, otel_modules
+
+
+def _always_off_span_metadata(
+    first_metadata: Mapping[str, Any] | None,
+    traceparent_metadata: Mapping[str, Any] | None,
+) -> tuple[Mapping[str, Any] | None, Any | None, Any | None, Any | None]:
+    otel_modules = _get_otel_modules()
+    if otel_modules is None:
+        return None, None, None, None
+    _, propagate, trace = otel_modules
+
+    parent_context = None
+    if traceparent_metadata is not None:
+        carrier = _trace_carrier(traceparent_metadata)
+        if carrier:
+            extracted_context = propagate.extract(carrier)
+            parent_span_context = trace.get_current_span(extracted_context).get_span_context()
+            if parent_span_context.is_valid:
+                parent_context = extracted_context
+
+    tracer = _get_always_off_tracer()
+    if tracer is None:
+        return None, None, None, None
+    return traceparent_metadata or first_metadata, parent_context, otel_modules, tracer
+
+
+def _trace_carrier(metadata: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        str(key).lower(): str(value)
+        for key, value in metadata.items()
+        if str(key).lower() in _TRACE_CONTEXT_METADATA_KEYS and value
+    }
+
+
+def _function_name(context_metadata: Any) -> str:
+    if isinstance(context_metadata, Mapping):
+        return str(context_metadata.get("function_name") or "") or "unknown"
+
+    if isinstance(context_metadata, Sequence) and not isinstance(context_metadata, str | bytes):
+        for item in context_metadata:
+            if isinstance(item, Mapping):
+                function_name = str(item.get("function_name") or "")
+                if function_name:
+                    return function_name
+
+    return "unknown"
+
+
+def _get_tracer(trace_api: Any) -> Any:
+    return trace_api.get_tracer(_TRACER_NAME)
+
+
+def _get_otel_modules() -> tuple[Any, Any, Any] | None:
+    global _otel_modules
+    if _otel_modules is None:
+        try:
+            _otel_modules = (
+                importlib.import_module("opentelemetry.context"),
+                importlib.import_module("opentelemetry.propagate"),
+                importlib.import_module("opentelemetry.trace"),
+            )
+        except ImportError:
+            _otel_modules = _missing_otel_modules
+
+    if _otel_modules is _missing_otel_modules:
+        return None
+    return cast(tuple[Any, Any, Any], _otel_modules)
+
+
+def _get_always_off_tracer() -> Any | None:
+    global _always_off_tracer
+    if _always_off_tracer is None:
+        try:
+            sdk_trace = importlib.import_module("opentelemetry.sdk.trace")
+            sdk_sampling = importlib.import_module("opentelemetry.sdk.trace.sampling")
+        except ImportError:
+            _always_off_tracer = _missing_always_off_tracer
+        else:
+            # Keep always-off local to this invocation instead of replacing the
+            # process-wide tracer provider.
+            provider = sdk_trace.TracerProvider(sampler=sdk_sampling.ALWAYS_OFF)
+            _always_off_tracer = provider.get_tracer(_TRACER_NAME)
+
+    if _always_off_tracer is _missing_always_off_tracer:
+        return None
+    return _always_off_tracer
+
+
+@contextlib.contextmanager
+def remote_function_invocation_span(
+    context_metadata: Any,
+    coalesced_count: int | None = None,
+) -> Iterator[None]:
+    policy = _trace_policy()
+    if policy is None:
+        yield
+        return
+
+    first_metadata, traceparent_metadata = _collect_trace_metadata(context_metadata)
+    if policy == _TRACE_POLICY_PARENT_BASED_ALWAYS_OFF and traceparent_metadata is None:
+        yield
+        return
+
+    if policy == _TRACE_POLICY_ALWAYS_OFF:
+        _metadata, parent_context, otel_modules, tracer = _always_off_span_metadata(
+            first_metadata,
+            traceparent_metadata,
+        )
+    else:
+        _metadata, parent_context, otel_modules = _span_metadata(
+            first_metadata,
+            traceparent_metadata,
+            policy,
+        )
+        tracer = _get_tracer(otel_modules[2]) if otel_modules is not None else None
+
+    if otel_modules is None:
+        yield
+        return
+    if tracer is None:
+        yield
+        return
+    otel_context, _, trace = otel_modules
+
+    SpanKind = trace.SpanKind
+    Status = trace.Status
+    StatusCode = trace.StatusCode
+    function_name = _function_name(context_metadata)
+    span_kwargs: dict[str, Any] = {"kind": SpanKind.SERVER}
+    if parent_context is not None:
+        span_kwargs["context"] = parent_context
+
+    with tracer.start_as_current_span("chalkcompute.remote_function.invoke", **span_kwargs) as span:
+        span.set_attribute("chalk.remote_function.name", function_name)
+        if coalesced_count is not None:
+            span.set_attribute(
+                "chalk.remote_function.coalesced_count",
+                coalesced_count,
+            )
+        if parent_context is not None and not span.get_span_context().is_valid:
+            token = otel_context.attach(parent_context)
+            try:
+                yield
+            finally:
+                otel_context.detach(token)
+            return
+        try:
+            yield
+        except Exception as exc:
+            span.record_exception(exc)
+            span.set_status(Status(StatusCode.ERROR, str(exc)))
+            raise

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk_remote_call_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.5.0
+Version: 1.6.0
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Typing :: Typed
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -18,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: pyarrow>=14.0.0
 Provides-Extra: dev

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/chalk_remote_call_python.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ chalk_remote_call/handler_loader.py
 chalk_remote_call/input_transform.py
 chalk_remote_call/server.py
 chalk_remote_call/servicer.py
+chalk_remote_call/tracing.py
 chalk_remote_call/_gen/__init__.py
 chalk_remote_call/_gen/chalk/__init__.py
 chalk_remote_call/_gen/chalk/auth/__init__.py

{chalk_remote_call_python-1.5.0 → chalk_remote_call_python-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chalk-remote-call-python"
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.15"
 authors = [
     { name = "Chalk AI, Inc." }
 ]
@@ -18,6 +18,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python",
     "Typing :: Typed",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",

chalk_remote_call_python-1.5.0/chalk_remote_call/_version.py

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