@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/common/src/protos/mod.rs

@@ -3,9 +3,11 @@
 //! that will match the generated structs in this module.
 
 pub mod constants;
+/// Utility functions for working with protobuf types.
 pub mod utilities;
 
 #[cfg(feature = "test-utilities")]
+/// Pre-built test histories for common workflow patterns.
 pub mod canned_histories;
 #[cfg(feature = "history_builders")]
 mod history_builder;
@@ -15,6 +17,8 @@ mod task_token;
 #[cfg(feature = "test-utilities")]
 pub mod test_utils;
 
+use std::time::Duration;
+
 #[cfg(feature = "history_builders")]
 pub use history_builder::{
     DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, default_act_sched,
@@ -24,12 +28,23 @@ pub use history_builder::{
 pub use history_info::HistoryInfo;
 pub use task_token::TaskToken;
 
+/// Payload metadata key that identifies the encoding format.
 pub static ENCODING_PAYLOAD_KEY: &str = "encoding";
+/// The metadata value for JSON-encoded payloads.
 pub static JSON_ENCODING_VAL: &str = "json/plain";
+/// The details key used in patched marker payloads.
 pub static PATCHED_MARKER_DETAILS_KEY: &str = "patch-data";
 /// The search attribute key used when registering change versions
 pub static VERSION_SEARCH_ATTR_KEY: &str = "TemporalChangeVersion";
 
+macro_rules! include_proto_with_serde {
+    ($pkg:tt) => {
+        tonic::include_proto!($pkg);
+
+        include!(concat!(env!("OUT_DIR"), concat!("/", $pkg, ".serde.rs")));
+    };
+}
+
 #[allow(
     clippy::large_enum_variant,
     clippy::derive_partial_eq_without_eq,
@@ -70,7 +85,7 @@ pub mod coresdk {
 
     #[allow(clippy::module_inception)]
     pub mod activity_task {
-        use crate::protos::{coresdk::ActivityTaskCompletion, task_token::fmt_tt};
+        use crate::protos::{coresdk::ActivityTaskCompletion, task_token::format_task_token};
         use std::fmt::{Display, Formatter};
         tonic::include_proto!("coresdk.activity_task");
 
@@ -119,7 +134,7 @@ pub mod coresdk {
                 write!(
                     f,
                     "ActivityTaskCompletion(token: {}",
-                    fmt_tt(&self.task_token),
+                    format_task_token(&self.task_token),
                 )?;
                 if let Some(r) = self.result.as_ref().and_then(|r| r.status.as_ref()) {
                     write!(f, ", {r}")?;
@@ -270,9 +285,7 @@ pub mod coresdk {
                 match self.status {
                     Some(activity_resolution::Status::Failed(Failure {
                         failure: Some(ref f),
-                    })) => f
-                        .is_timeout()
-                        .or_else(|| f.cause.as_ref().and_then(|c| c.is_timeout())),
+                    })) => f.is_timeout(),
                     _ => None,
                 }
             }
@@ -521,6 +534,7 @@ pub mod coresdk {
                 deployment_version_for_current_task: None,
                 last_sdk_version: String::new(),
                 suggest_continue_as_new_reasons: vec![],
+                target_worker_deployment_version_changed: false,
             }
         }
 
@@ -821,16 +835,35 @@ pub mod coresdk {
                     nexus_task_completion::Status::Completed(c) => {
                         write!(f, "{c}")
                     }
-                    nexus_task_completion::Status::Error(e) => {
-                        write!(f, "{e}")
-                    }
                     nexus_task_completion::Status::AckCancel(_) => {
                         write!(f, "AckCancel")
                     }
+                    #[allow(deprecated)]
+                    nexus_task_completion::Status::Error(error) => {
+                        write!(f, "Error({error:?})")
+                    }
+                    nexus_task_completion::Status::Failure(failure) => {
+                        write!(f, "{failure}")
+                    }
                 }?;
                 write!(f, ")")
             }
         }
+
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub enum NexusOperationErrorState {
+            Failed,
+            Canceled,
+        }
+
+        impl Display for NexusOperationErrorState {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    Self::Failed => write!(f, "failed"),
+                    Self::Canceled => write!(f, "canceled"),
+                }
+            }
+        }
     }
 
     pub mod workflow_commands {
@@ -942,11 +975,12 @@ pub mod coresdk {
 
         impl Display for UpsertWorkflowSearchAttributes {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                write!(
-                    f,
-                    "UpsertWorkflowSearchAttributes({:?})",
-                    self.search_attributes.keys()
-                )
+                let keys: Vec<_> = self
+                    .search_attributes
+                    .as_ref()
+                    .map(|sa| sa.indexed_fields.keys().collect())
+                    .unwrap_or_default();
+                write!(f, "UpsertWorkflowSearchAttributes({:?})", keys)
             }
         }
 
@@ -1314,7 +1348,13 @@ pub mod coresdk {
         pub fn is_timeout(&self) -> Option<crate::protos::temporal::api::enums::v1::TimeoutType> {
             match &self.failure_info {
                 Some(FailureInfo::TimeoutFailureInfo(ti)) => Some(ti.timeout_type()),
-                _ => None,
+                _ => {
+                    if let Some(c) = &self.cause {
+                        c.is_timeout()
+                    } else {
+                        None
+                    }
+                }
             }
         }
 
@@ -1780,7 +1820,7 @@ pub mod temporal {
                     fn from(s: workflow_commands::UpsertWorkflowSearchAttributes) -> Self {
                         Self::UpsertWorkflowSearchAttributesCommandAttributes(
                             UpsertWorkflowSearchAttributesCommandAttributes {
-                                search_attributes: Some(s.search_attributes.into()),
+                                search_attributes: s.search_attributes,
                             },
                         )
                     }
@@ -1845,7 +1885,7 @@ pub mod temporal {
                             task_queue: Some(s.task_queue.into()),
                             header: Some(s.headers.into()),
                             memo: Some(s.memo.into()),
-                            search_attributes: Some(s.search_attributes.into()),
+                            search_attributes: s.search_attributes,
                             input: s.input.into_payloads(),
                             workflow_id_reuse_policy: s.workflow_id_reuse_policy,
                             workflow_execution_timeout: s.workflow_execution_timeout,
@@ -1903,11 +1943,7 @@ pub mod temporal {
                                 Some(c.headers.into())
                             },
                             retry_policy: c.retry_policy,
-                            search_attributes: if c.search_attributes.is_empty() {
-                                None
-                            } else {
-                                Some(c.search_attributes.into())
-                            },
+                            search_attributes: c.search_attributes,
                             inherit_build_id,
                             initial_versioning_behavior: c.initial_versioning_behavior,
                             ..Default::default()
@@ -2007,7 +2043,7 @@ pub mod temporal {
                     collections::HashMap,
                     fmt::{Display, Formatter},
                 };
-                tonic::include_proto!("temporal.api.common.v1");
+                include_proto_with_serde!("temporal.api.common.v1");
 
                 impl<T> From<T> for Payload
                 where
@@ -2140,12 +2176,17 @@ pub mod temporal {
         }
         pub mod enums {
             pub mod v1 {
-                tonic::include_proto!("temporal.api.enums.v1");
+                include_proto_with_serde!("temporal.api.enums.v1");
+            }
+        }
+        pub mod errordetails {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.errordetails.v1");
             }
         }
         pub mod failure {
             pub mod v1 {
-                tonic::include_proto!("temporal.api.failure.v1");
+                include_proto_with_serde!("temporal.api.failure.v1");
             }
         }
         pub mod filter {
@@ -2552,13 +2593,20 @@ pub mod temporal {
                 use crate::protos::{
                     camel_case_to_screaming_snake,
                     temporal::api::{
-                        common,
-                        common::v1::link::{WorkflowEvent, workflow_event},
+                        common::{
+                            self,
+                            v1::link::{WorkflowEvent, workflow_event},
+                        },
                         enums::v1::EventType,
+                        failure,
                     },
                 };
                 use anyhow::{anyhow, bail};
-                use std::fmt::{Display, Formatter};
+                use prost::Name;
+                use std::{
+                    collections::HashMap,
+                    fmt::{Display, Formatter},
+                };
                 use tonic::transport::Uri;
 
                 tonic::include_proto!("temporal.api.nexus.v1");
@@ -2595,6 +2643,11 @@ pub mod temporal {
                     }
                 }
 
+                pub enum NexusTaskFailure {
+                    Legacy(HandlerError),
+                    Temporal(failure::v1::Failure),
+                }
+
                 static SCHEME_PREFIX: &str = "temporal://";
 
                 /// Attempt to parse a nexus lint into a workflow event link
@@ -2676,6 +2729,30 @@ pub mod temporal {
                         })),
                     })
                 }
+
+                impl TryFrom<failure::v1::Failure> for Failure {
+                    type Error = serde_json::Error;
+
+                    fn try_from(mut f: failure::v1::Failure) -> Result<Self, Self::Error> {
+                        // 1. Remove message from failure
+                        let message = std::mem::take(&mut f.message);
+
+                        // 2. Serialize Failure as JSON
+                        let details = serde_json::to_vec(&f)?;
+
+                        // 3. Package Temporal Failure as Nexus Failure
+                        Ok(Failure {
+                            message,
+                            stack_trace: f.stack_trace,
+                            metadata: HashMap::from([(
+                                "type".to_string(),
+                                failure::v1::Failure::full_name().into(),
+                            )]),
+                            details,
+                            cause: None,
+                        })
+                    }
+                }
             }
         }
         pub mod workflowservice {
@@ -2791,6 +2868,18 @@ pub mod temporal {
     }
 }
 
+#[allow(
+    clippy::all,
+    missing_docs,
+    rustdoc::broken_intra_doc_links,
+    rustdoc::bare_urls
+)]
+pub mod google {
+    pub mod rpc {
+        tonic::include_proto!("google.rpc");
+    }
+}
+
 #[allow(
     clippy::all,
     missing_docs,
@@ -2824,6 +2913,12 @@ pub fn camel_case_to_screaming_snake(val: &str) -> String {
     out
 }
 
+/// Convert a protobuf [`prost_types::Timestamp`] to a [`std::time::SystemTime`].
+pub fn proto_ts_to_system_time(ts: &prost_types::Timestamp) -> Option<std::time::SystemTime> {
+    std::time::SystemTime::UNIX_EPOCH
+        .checked_add(Duration::from_secs(ts.seconds as u64) + Duration::from_nanos(ts.nanos as u64))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::protos::temporal::api::failure::v1::Failure;

package/sdk-core/crates/common/src/protos/task_token.rs

@@ -36,13 +36,13 @@ impl TaskToken {
 
 impl Display for TaskToken {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&fmt_tt(&self.0))
+        f.write_str(&format_task_token(&self.0))
     }
 }
 
 impl Debug for TaskToken {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&format!("TaskToken({})", fmt_tt(&self.0)))
+        f.write_str(&format!("TaskToken({})", format_task_token(&self.0)))
     }
 }
 
@@ -52,6 +52,6 @@ impl Borrow<[u8]> for TaskToken {
     }
 }
 
-pub(crate) fn fmt_tt(tt: &[u8]) -> String {
+pub(crate) fn format_task_token(tt: &[u8]) -> String {
     BASE64_STANDARD.encode(tt)
 }

package/sdk-core/crates/common/src/protos/utilities.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use prost::{EncodeError, Message};
 
+/// Extension trait for converting `Option<F>` to `Option<T>`, returning `None` on failure.
 pub trait TryIntoOrNone<F, T> {
     /// Turn an option of something into an option of another thing, trying to convert along the way
     /// and returning `None` if that conversion fails
@@ -26,6 +27,16 @@ pub fn pack_any<T: Message>(type_url: String, msg: &T) -> Result<prost_types::An
     Ok(prost_types::Any { type_url, value })
 }
 
+/// Decode a specific protobuf message type from gRPC status details bytes.
+///
+/// The details bytes should be the serialized `google.rpc.Status` message from
+/// `tonic::Status::details()`.
+pub fn decode_status_detail<T: Message + Default>(details: &[u8]) -> Option<T> {
+    let status = super::google::rpc::Status::decode(details).ok()?;
+    let first_detail = status.details.first()?;
+    T::decode(first_detail.value.as_slice()).ok()
+}
+
 /// Given a header map, lowercase all the keys and return it as a new map.
 /// Any keys that are duplicated after lowercasing will clobber each other in undefined ordering.
 pub fn normalize_http_headers(headers: HashMap<String, String>) -> HashMap<String, String> {

package/sdk-core/crates/{sdk-core → common}/src/telemetry/log_export.rs

@@ -1,8 +1,8 @@
+use crate::telemetry::{CoreLog, CoreLogConsumer};
 use futures_channel::mpsc::{Receiver, Sender, channel};
 use parking_lot::Mutex;
 use ringbuf::{HeapRb, consumer::Consumer, producer::Producer, traits::Split};
 use std::{collections::HashMap, fmt, sync::Arc, time::SystemTime};
-use temporalio_common::telemetry::{CoreLog, CoreLogConsumer};
 use tracing_subscriber::Layer;
 
 #[derive(Debug)]
@@ -215,18 +215,15 @@ impl tracing::field::Visit for JsonVisitor<'_> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        telemetry::{CoreLogStreamConsumer, construct_filter_string},
-        telemetry_init,
+    use crate::telemetry::{
+        CoreLog, CoreLogConsumer, CoreLogStreamConsumer, CoreTelemetry, Logger, TelemetryOptions,
+        construct_filter_string, telemetry_init,
     };
     use futures_util::stream::StreamExt;
     use std::{
         fmt,
         sync::{Arc, Mutex},
     };
-    use temporalio_common::telemetry::{
-        CoreLog, CoreLogConsumer, CoreTelemetry, Logger, TelemetryOptions,
-    };
     use tracing::Level;
 
     #[instrument(fields(bros = "brohemian"))]
@@ -246,6 +243,7 @@ mod tests {
 
     fn assert_logs(logs: Vec<CoreLog>) {
         // Verify debug log was not forwarded
+        dbg!(&logs);
         assert!(!logs.iter().any(|l| l.message == "debug"));
         assert_eq!(logs.len(), 4);
         // Ensure fields are attached to events properly

package/sdk-core/crates/common/src/telemetry/metrics/core.rs

@@ -0,0 +1,125 @@
+//! Metrics related code only needed by core and core-based SDKs
+
+use crate::telemetry::metrics::{MetricKeyValue, MetricParameters};
+use std::{
+    any::Any,
+    fmt::Debug,
+    sync::{Arc, OnceLock},
+    time::Duration,
+};
+
+/// A reference to some attributes created lang side.
+pub trait CustomMetricAttributes: Debug + Send + Sync {
+    /// Must be implemented to work around existing type system restrictions, see
+    /// [here](https://internals.rust-lang.org/t/downcast-not-from-any-but-from-any-trait/16736/12)
+    fn as_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync>;
+}
+
+/// Events produced by the metrics buffering layer for deferred processing by lang.
+#[derive(Debug, Clone)]
+pub enum MetricEvent<I: BufferInstrumentRef> {
+    /// Request to create a new metric instrument.
+    Create {
+        /// Parameters (name, description, unit) for the new instrument.
+        params: MetricParameters,
+        /// Once you receive this event, call `set` on this with the initialized instrument
+        /// reference
+        populate_into: LazyBufferInstrument<I>,
+        /// The kind of metric instrument to create.
+        kind: MetricKind,
+    },
+    /// Request to create a new set of metric attributes.
+    CreateAttributes {
+        /// Once you receive this event, call `set` on this with the initialized attributes
+        populate_into: BufferAttributes,
+        /// If not `None`, use these already-initialized attributes as the base (extended with
+        /// `attributes`) for the ones you are about to initialize.
+        append_from: Option<BufferAttributes>,
+        /// The key-value pairs for the new attribute set.
+        attributes: Vec<MetricKeyValue>,
+    },
+    /// A metric recording to apply to an already-created instrument.
+    Update {
+        /// The instrument to record against.
+        instrument: LazyBufferInstrument<I>,
+        /// The attributes to associate with this recording.
+        attributes: BufferAttributes,
+        /// The value to record.
+        update: MetricUpdateVal,
+    },
+}
+/// The kind of metric instrument to create.
+#[derive(Debug, Clone, Copy)]
+pub enum MetricKind {
+    /// A monotonically increasing `u64` counter.
+    Counter,
+    /// A `u64` gauge that can go up or down.
+    Gauge,
+    /// An `f64` gauge that can go up or down.
+    GaugeF64,
+    /// A `u64` histogram for recording distributions.
+    Histogram,
+    /// An `f64` histogram for recording distributions.
+    HistogramF64,
+    /// A histogram that records [`Duration`] values.
+    HistogramDuration,
+}
+/// The value to record when updating a metric instrument.
+#[derive(Debug, Clone, Copy)]
+pub enum MetricUpdateVal {
+    /// A `u64` delta increment (for counters/histograms).
+    Delta(u64),
+    /// An `f64` delta increment (for f64 histograms).
+    DeltaF64(f64),
+    /// An absolute `u64` value (for gauges).
+    Value(u64),
+    /// An absolute `f64` value (for f64 gauges).
+    ValueF64(f64),
+    /// A duration observation (for duration histograms).
+    Duration(Duration),
+}
+
+/// Collects buffered metric events for later replay into a real metrics backend.
+pub trait MetricCallBufferer<I: BufferInstrumentRef>: Send + Sync {
+    /// Drain and return all buffered metric events.
+    fn retrieve(&self) -> Vec<MetricEvent<I>>;
+}
+
+/// A lazy reference to some metrics buffer attributes
+pub type BufferAttributes = LazyRef<Arc<dyn CustomMetricAttributes + 'static>>;
+
+/// Types lang uses to contain references to its lang-side defined instrument references must
+/// implement this marker trait
+pub trait BufferInstrumentRef {}
+/// A lazy reference to a metrics buffer instrument
+pub type LazyBufferInstrument<T> = LazyRef<Arc<T>>;
+
+/// A shared, lazily-initialized reference. Created as an empty "hole" and filled later via [`set`](Self::set).
+#[derive(Debug, Clone)]
+pub struct LazyRef<T> {
+    to_be_initted: Arc<OnceLock<T>>,
+}
+impl<T> LazyRef<T> {
+    /// Create an uninitialized hole that must be filled with [`set`](Self::set) before use.
+    pub fn hole() -> Self {
+        Self {
+            to_be_initted: Arc::new(OnceLock::new()),
+        }
+    }
+
+    /// Get the reference you previously initialized
+    ///
+    /// # Panics
+    /// If `set` has not already been called. You must set the reference before using it.
+    pub fn get(&self) -> &T {
+        self.to_be_initted
+            .get()
+            .expect("You must initialize the reference before using it")
+    }
+
+    /// Assigns a value to fill this reference.
+    /// Returns according to semantics of [OnceLock].
+    pub fn set(&self, val: T) -> Result<(), T> {
+        self.to_be_initted.set(val)
+    }
+}