@temporalio/core-bridge 1.9.2 → 1.10.0

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -1,11 +1,3 @@
-#[cfg(feature = "save_wf_inputs")]
-mod saved_wf_inputs;
-#[cfg(feature = "save_wf_inputs")]
-mod tonic_status_serde;
-
-#[cfg(feature = "save_wf_inputs")]
-pub use saved_wf_inputs::replay_wf_state_inputs;
-
 use crate::{
     abstractions::dbg_panic,
     worker::workflow::{
@@ -30,8 +22,10 @@ use tracing::{Level, Span};
 /// See [WFStream::build] for more
 pub(super) struct WFStream {
     runs: RunCache,
-    /// Buffered polls for new runs which need a cache slot to open up before we can handle them
-    buffered_polls_need_cache_slot: VecDeque<PermittedWFT>,
+    /// Buffered polls for new runs which need a cache slot to open up before we can handle them.
+    /// The inner list is possibly multiple buffered tasks for one run, which can happen if there
+    /// is a backlog of queries.
+    buffered_polls_need_cache_slot: VecDeque<Vec<PermittedWFT>>,
     /// Is filled with runs that we decided need to have their history fetched during state
     /// manipulation. Must be drained after handling each input.
     runs_needing_fetching: VecDeque<HistoryFetchReq>,
@@ -41,9 +35,6 @@ pub(super) struct WFStream {
     ignore_evicts_on_shutdown: bool,
 
     metrics: MetricsContext,
-
-    #[cfg(feature = "save_wf_inputs")]
-    wf_state_inputs: Option<UnboundedSender<Vec<u8>>>,
 }
 impl WFStream {
     /// Constructs workflow state management and returns a stream which outputs activations.
@@ -105,18 +96,12 @@ impl WFStream {
             metrics: basics.metrics,
             runs_needing_fetching: Default::default(),
             history_fetch_refcounter: Arc::new(HistfetchRC {}),
-
-            #[cfg(feature = "save_wf_inputs")]
-            wf_state_inputs: basics.worker_config.wf_state_inputs.clone(),
         };
         all_inputs
             .map(move |action: WFStreamInput| {
                 let span = span!(Level::DEBUG, "new_stream_input", action=?action);
                 let _span_g = span.enter();
 
-                #[cfg(feature = "save_wf_inputs")]
-                let maybe_write = state.prep_input(&action);
-
                 let mut activations = vec![];
                 let maybe_act = match action {
                     WFStreamInput::NewWft(pwft) => {
@@ -188,14 +173,6 @@ impl WFStream {
                 activations.extend(maybe_act);
                 activations.extend(state.reconcile_buffered());
 
-                // Always flush *after* actually handling the input, as this allows LA sink
-                // responses to be recorded before the input, so they can be read and buffered to be
-                // replayed during the handling of the input itself.
-                #[cfg(feature = "save_wf_inputs")]
-                if let Some(write) = maybe_write {
-                    state.flush_write(write);
-                }
-
                 if state.shutdown_done() {
                     info!("Workflow shutdown is done");
                     return Err(PollWfError::ShutDown);
@@ -366,27 +343,36 @@ impl WFStream {
                 debug!(run_id=%run_id, "Evicting run");
                 self.runs.remove(run_id);
             }
-            let maybe_ready_wft =
-                maybe_buffered
-                    .get_next_wft()
-                    .or(wft_from_complete)
-                    .or_else(|| {
-                        // Attempt to apply a buffered poll for some *other* run, if we didn't have a
-                        // wft from complete or a buffered poll for *this* run and we evicted
-                        if should_evict {
-                            self.buffered_polls_need_cache_slot.pop_front()
-                        } else {
-                            None
-                        }
-                    });
-            if let Some(wft) = maybe_ready_wft {
-                res = self.instantiate_or_update(wft);
+            let maybe_ready_wft = maybe_buffered
+                .get_next_wft()
+                .or(wft_from_complete)
+                .map(|x| vec![x])
+                .or_else(|| {
+                    // Attempt to apply a buffered poll for some *other* run, if we didn't have a
+                    // wft from complete or a buffered poll for *this* run and we evicted
+                    if should_evict {
+                        self.buffered_polls_need_cache_slot.pop_front()
+                    } else {
+                        None
+                    }
+                });
+            let mut maybe_wfts = maybe_ready_wft.unwrap_or_default();
+            if let Some(first_wft) = maybe_wfts.pop() {
+                res = self.instantiate_or_update(first_wft);
                 // We accept that there might be query tasks remaining in the buffer if we evicted
                 // and re-instantiated here. It's likely those tasks are now invalidated anyway.
                 if maybe_buffered.has_tasks() && should_evict {
                     warn!("There were leftover buffered tasks when evicting run");
                 }
             }
+            // If there happened to be more than one buffered WFT for this run, move them into the
+            // now-instantiated run's buffer.
+            for wft in maybe_wfts {
+                let should_be_nothing = self.instantiate_or_update(wft);
+                if should_be_nothing.is_some() {
+                    dbg_panic!("Extra buffered run should not have produced an activation");
+                }
+            }
         }
 
         if res.is_none() {
@@ -484,16 +470,15 @@ impl WFStream {
 
     fn buffer_resp_on_full_cache(&mut self, work: PermittedWFT) {
         debug!(run_id=%work.work.execution.run_id, "Buffering WFT because cache is full");
-        // If there's already a buffered poll for the run, replace it.
-        if let Some(rh) = self
-            .buffered_polls_need_cache_slot
-            .iter_mut()
-            .find(|w| w.work.execution.run_id == work.work.execution.run_id)
-        {
-            *rh = work;
+        // If there's already a buffered poll for the run, add to it.
+        if let Some(rh) = self.buffered_polls_need_cache_slot.iter_mut().find(|w| {
+            w.first()
+                .is_some_and(|ww| ww.work.execution.run_id == work.work.execution.run_id)
+        }) {
+            rh.push(work);
         } else {
-            // Otherwise push it to the back
-            self.buffered_polls_need_cache_slot.push_back(work);
+            //  Otherwise push it to the back
+            self.buffered_polls_need_cache_slot.push_back(vec![work]);
         }
     }
 
@@ -571,10 +556,6 @@ impl WFStream {
 
 /// All possible inputs to the [WFStream]
 #[derive(derive_more::From, Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 enum WFStreamInput {
     NewWft(PermittedWFT),
     Local(LocalInput),
@@ -582,19 +563,9 @@ enum WFStreamInput {
     PollerDead,
     /// The stream given to us which represents the poller (or a mock) encountered a non-retryable
     /// error while polling
-    PollerError(
-        #[cfg_attr(
-            feature = "save_wf_inputs",
-            serde(with = "tonic_status_serde::SerdeStatus")
-        )]
-        tonic::Status,
-    ),
+    PollerError(tonic::Status),
     FailedFetch {
         run_id: String,
-        #[cfg_attr(
-            feature = "save_wf_inputs",
-            serde(with = "tonic_status_serde::SerdeStatus")
-        )]
         err: tonic::Status,
         auto_reply_fail_tt: Option<TaskToken>,
     },
@@ -602,15 +573,10 @@ enum WFStreamInput {
 
 /// A non-poller-received input to the [WFStream]
 #[derive(derive_more::DebugCustom)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 #[debug(fmt = "LocalInput {{ {input:?} }}")]
 pub(super) struct LocalInput {
-    pub input: LocalInputs,
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip, default = "Span::current"))]
-    pub span: Span,
+    pub(super) input: LocalInputs,
+    pub(super) span: Span,
 }
 impl From<HeartbeatTimeoutMsg> for LocalInput {
     fn from(hb: HeartbeatTimeoutMsg) -> Self {
@@ -623,10 +589,6 @@ impl From<HeartbeatTimeoutMsg> for LocalInput {
 /// Everything that _isn't_ a poll which may affect workflow state. Always higher priority than
 /// new polls.
 #[derive(Debug, derive_more::From)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 pub(super) enum LocalInputs {
     Completion(WFActCompleteMsg),
     FetchedPageCompletion {
@@ -637,7 +599,6 @@ pub(super) enum LocalInputs {
     PostActivation(PostActivationMsg),
     RequestEviction(RequestEvictMsg),
     HeartbeatTimeout(String),
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     GetStateInfo(GetStateInfoMsg),
 }
 impl LocalInputs {

package/sdk-core/core-api/Cargo.toml

@@ -13,18 +13,16 @@ categories = ["development-tools"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-otel_impls = ["opentelemetry"]
+otel_impls = ["dep:opentelemetry"]
 
 [dependencies]
 async-trait = "0.1"
-derive_builder = "0.12"
+derive_builder = { workspace = true }
 derive_more = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
-prost-types = "0.11"
-serde = { version = "1.0", default_features = false, features = ["derive"] }
+prost-types = { workspace = true }
 serde_json = "1.0"
 thiserror = "1.0"
-tokio = "1.24"
 tonic = { workspace = true }
 tracing-core = "0.1"
 url = "2.3"
@@ -32,3 +30,6 @@ url = "2.3"
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
 version = "0.1"
+
+[lints]
+workspace = true

package/sdk-core/core-api/src/errors.rs

@@ -60,3 +60,11 @@ pub enum CompleteActivityError {
         completion: Option<ActivityExecutionResult>,
     },
 }
+
+/// Errors we can encounter during workflow processing which we may treat as either WFT failures
+/// or whole-workflow failures depending on user preference.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum WorkflowErrorType {
+    /// A nondeterminism error
+    Nondeterminism,
+}

package/sdk-core/core-api/src/telemetry/metrics.rs

@@ -3,6 +3,7 @@ use std::{
     borrow::Cow,
     fmt::Debug,
     sync::{Arc, OnceLock},
+    time::Duration,
 };
 
 /// Implementors of this trait are expected to be defined in each language's bridge.
@@ -23,7 +24,14 @@ pub trait CoreMeter: Send + Sync + Debug {
     ) -> MetricAttributes;
     fn counter(&self, params: MetricParameters) -> Arc<dyn Counter>;
     fn histogram(&self, params: MetricParameters) -> Arc<dyn Histogram>;
+    fn histogram_f64(&self, params: MetricParameters) -> Arc<dyn HistogramF64>;
+    /// Create a histogram which records Durations. Implementations should choose to emit in
+    /// either milliseconds or seconds depending on how they have been configured.
+    /// [MetricParameters::unit] should be overwritten by implementations to be `ms` or `s`
+    /// accordingly.
+    fn histogram_duration(&self, params: MetricParameters) -> Arc<dyn HistogramDuration>;
     fn gauge(&self, params: MetricParameters) -> Arc<dyn Gauge>;
+    fn gauge_f64(&self, params: MetricParameters) -> Arc<dyn GaugeF64>;
 }
 
 #[derive(Debug, Clone, derive_builder::Builder)]
@@ -74,9 +82,22 @@ impl CoreMeter for Arc<dyn CoreMeter> {
     fn histogram(&self, params: MetricParameters) -> Arc<dyn Histogram> {
         self.as_ref().histogram(params)
     }
+
+    fn histogram_f64(&self, params: MetricParameters) -> Arc<dyn HistogramF64> {
+        self.as_ref().histogram_f64(params)
+    }
+
+    fn histogram_duration(&self, params: MetricParameters) -> Arc<dyn HistogramDuration> {
+        self.as_ref().histogram_duration(params)
+    }
+
     fn gauge(&self, params: MetricParameters) -> Arc<dyn Gauge> {
         self.as_ref().gauge(params)
     }
+
+    fn gauge_f64(&self, params: MetricParameters) -> Arc<dyn GaugeF64> {
+        self.as_ref().gauge_f64(params)
+    }
 }
 
 /// Attributes which are provided every time a call to record a specific metric is made.
@@ -158,22 +179,34 @@ pub trait Histogram: Send + Sync {
     // When referring to durations, this value is in millis
     fn record(&self, value: u64, attributes: &MetricAttributes);
 }
+pub trait HistogramF64: Send + Sync {
+    // When referring to durations, this value is in seconds
+    fn record(&self, value: f64, attributes: &MetricAttributes);
+}
+pub trait HistogramDuration: Send + Sync {
+    fn record(&self, value: Duration, attributes: &MetricAttributes);
+}
 
 pub trait Gauge: Send + Sync {
     // When referring to durations, this value is in millis
     fn record(&self, value: u64, attributes: &MetricAttributes);
 }
+pub trait GaugeF64: Send + Sync {
+    // When referring to durations, this value is in seconds
+    fn record(&self, value: f64, attributes: &MetricAttributes);
+}
 
 #[derive(Debug, Clone)]
 pub enum MetricEvent<I: BufferInstrumentRef> {
     Create {
         params: MetricParameters,
-        /// One you receive this event, call `set` on this with the initialized instrument reference
+        /// Once you receive this event, call `set` on this with the initialized instrument
+        /// reference
         populate_into: LazyBufferInstrument<I>,
         kind: MetricKind,
     },
     CreateAttributes {
-        /// One you receive this event, call `set` on this with the initialized attributes
+        /// 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.
@@ -190,14 +223,18 @@ pub enum MetricEvent<I: BufferInstrumentRef> {
 pub enum MetricKind {
     Counter,
     Gauge,
+    GaugeF64,
     Histogram,
+    HistogramF64,
+    HistogramDuration,
 }
 #[derive(Debug, Clone, Copy)]
 pub enum MetricUpdateVal {
-    // Currently all deltas are natural numbers
     Delta(u64),
-    // Currently all values are natural numbers
+    DeltaF64(f64),
     Value(u64),
+    ValueF64(f64),
+    Duration(Duration),
 }
 
 pub trait MetricCallBufferer<I: BufferInstrumentRef>: Send + Sync {
@@ -260,9 +297,21 @@ impl CoreMeter for NoOpCoreMeter {
         Arc::new(NoOpInstrument)
     }
 
+    fn histogram_f64(&self, _: MetricParameters) -> Arc<dyn HistogramF64> {
+        Arc::new(NoOpInstrument)
+    }
+
+    fn histogram_duration(&self, _: MetricParameters) -> Arc<dyn HistogramDuration> {
+        Arc::new(NoOpInstrument)
+    }
+
     fn gauge(&self, _: MetricParameters) -> Arc<dyn Gauge> {
         Arc::new(NoOpInstrument)
     }
+
+    fn gauge_f64(&self, _: MetricParameters) -> Arc<dyn GaugeF64> {
+        Arc::new(NoOpInstrument)
+    }
 }
 
 pub struct NoOpInstrument;
@@ -272,9 +321,18 @@ impl Counter for NoOpInstrument {
 impl Histogram for NoOpInstrument {
     fn record(&self, _: u64, _: &MetricAttributes) {}
 }
+impl HistogramF64 for NoOpInstrument {
+    fn record(&self, _: f64, _: &MetricAttributes) {}
+}
+impl HistogramDuration for NoOpInstrument {
+    fn record(&self, _: Duration, _: &MetricAttributes) {}
+}
 impl Gauge for NoOpInstrument {
     fn record(&self, _: u64, _: &MetricAttributes) {}
 }
+impl GaugeF64 for NoOpInstrument {
+    fn record(&self, _: f64, _: &MetricAttributes) {}
+}
 
 #[derive(Debug, Clone)]
 pub struct NoOpAttributes;
@@ -331,4 +389,17 @@ mod otel_impls {
             }
         }
     }
+
+    impl HistogramF64 for metrics::Histogram<f64> {
+        fn record(&self, value: f64, attributes: &MetricAttributes) {
+            if let MetricAttributes::OTel { kvs } = attributes {
+                self.record(value, kvs);
+            } else {
+                debug_assert!(
+                    false,
+                    "Must use OTel attributes with an OTel metric implementation"
+                );
+            }
+        }
+    }
 }

package/sdk-core/core-api/src/telemetry.rs

@@ -61,9 +61,12 @@ pub struct OtelCollectorOptions {
     /// Specifies the aggregation temporality for metric export. Defaults to cumulative.
     #[builder(default = "MetricTemporality::Cumulative")]
     pub metric_temporality: MetricTemporality,
-    // A map of tags to be applied to all metrics
+    /// A map of tags to be applied to all metrics
     #[builder(default)]
     pub global_tags: HashMap<String, String>,
+    /// If set to true, use f64 seconds for durations instead of u64 milliseconds
+    #[builder(default)]
+    pub use_seconds_for_durations: bool,
 }
 
 /// Options for exporting metrics to Prometheus
@@ -80,6 +83,9 @@ pub struct PrometheusExporterOptions {
     /// Ex: "_milliseconds".
     #[builder(default = "false")]
     pub unit_suffix: bool,
+    /// If set to true, use f64 seconds for durations instead of u64 milliseconds
+    #[builder(default)]
+    pub use_seconds_for_durations: bool,
 }
 
 /// Control where logs go