@temporalio/core-bridge 1.11.8 → 1.12.0

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -51,7 +51,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant, SystemTime},
 };
-use temporal_sdk_core_api::worker::WorkerConfig;
+use temporal_sdk_core_api::worker::{WorkerConfig, WorkerDeploymentVersion};
 use temporal_sdk_core_protos::{
     coresdk::{
         common::{NamespacedWorkflowExecution, VersioningIntent},
@@ -123,8 +123,9 @@ pub(crate) struct WorkflowMachines {
     history_size_bytes: u64,
     /// Set on each WFT started event
     continue_as_new_suggested: bool,
-    /// Set if the current WFT is already complete and that completion event had a build id in it.
-    current_wft_build_id: Option<String>,
+    /// Set if the current WFT is already complete and that completion event had legacy build-id
+    /// or a deployment version in it. Will use an empty deployment name if it's legacy build-id.
+    current_wft_deployment_info: Option<WorkerDeploymentVersion>,
 
     all_machines: SlotMap<MachineKey, Machines>,
     /// If a machine key is in this map, that machine was created internally by core, not as a
@@ -286,7 +287,7 @@ impl WorkflowMachines {
             observed_internal_flags: Rc::new(RefCell::new(observed_internal_flags)),
             history_size_bytes: 0,
             continue_as_new_suggested: false,
-            current_wft_build_id: None,
+            current_wft_deployment_info: None,
             all_machines: Default::default(),
             machine_is_core_created: Default::default(),
             machines_by_event_id: Default::default(),
@@ -442,11 +443,11 @@ impl WorkflowMachines {
             )
         });
         let is_replaying = self.replaying || all_query;
-        let build_id_for_current_task = if is_replaying {
-            self.current_wft_build_id.clone().unwrap_or_default()
+        let deployment_version_for_current_task = if is_replaying {
+            self.current_wft_deployment_info.clone()
         } else {
-            self.current_wft_build_id = Some(self.worker_config.worker_build_id.clone());
-            self.worker_config.worker_build_id.clone()
+            self.current_wft_deployment_info = self.worker_config.computed_deployment_version();
+            self.current_wft_deployment_info.clone()
         };
         WorkflowActivation {
             timestamp: self.current_wf_time.map(Into::into),
@@ -460,7 +461,8 @@ impl WorkflowMachines {
                 .collect(),
             history_size_bytes: self.history_size_bytes,
             continue_as_new_suggested: self.continue_as_new_suggested,
-            build_id_for_current_task,
+            deployment_version_for_current_task: deployment_version_for_current_task
+                .map(Into::into),
         }
     }
 
@@ -479,9 +481,7 @@ impl WorkflowMachines {
         // If this worker has a build ID and we're completing the task, we want to say our ID is the
         // current build ID, so that if we get a query before any new history, we properly can
         // report that our ID was the one used for the completion.
-        if !self.worker_config.worker_build_id.is_empty() {
-            self.current_wft_build_id = Some(self.worker_config.worker_build_id.clone());
-        }
+        self.current_wft_deployment_info = self.worker_config.computed_deployment_version();
         (*self.observed_internal_flags)
             .borrow_mut()
             .gather_for_wft_complete()
@@ -512,15 +512,11 @@ impl WorkflowMachines {
         self.last_processed_event -= 2;
         // Then, we have to drop any state machines (which should only be one workflow task machine)
         // we may have created when servicing the speculative task.
-        // Remove when https://github.com/rust-lang/rust/issues/59618 is stable
         let remove_these: Vec<_> = self
             .machines_by_event_id
-            .iter()
-            .filter(|(mid, _)| **mid > self.last_processed_event)
-            .map(|(mid, mkey)| (*mid, *mkey))
+            .extract_if(|mid, _| *mid > self.last_processed_event)
             .collect();
-        for (mid, mkey) in remove_these {
-            self.machines_by_event_id.remove(&mid);
+        for (_, mkey) in remove_these {
             self.all_machines.remove(mkey);
         }
     }
@@ -531,10 +527,10 @@ impl WorkflowMachines {
         let results = self.drive_me.fetch_workflow_iteration_output();
         self.handle_driven_results(results)?;
         self.prepare_commands()?;
-        if self.workflow_is_finished() {
-            if let Some(rt) = self.total_runtime() {
-                self.metrics.wf_e2e_latency(rt);
-            }
+        if self.workflow_is_finished()
+            && let Some(rt) = self.total_runtime()
+        {
+            self.metrics.wf_e2e_latency(rt);
         }
         Ok(())
     }
@@ -587,8 +583,28 @@ impl WorkflowMachines {
                 (*$me.observed_internal_flags)
                     .borrow_mut()
                     .add_from_complete($wtc);
+                let mut combined_ver = WorkerDeploymentVersion {
+                    deployment_name: "".to_string(),
+                    build_id: "".to_string(),
+                };
+                #[allow(deprecated)]
                 if let Some(bid) = $wtc.worker_version.as_ref().map(|wv| &wv.build_id) {
-                    $me.current_wft_build_id = Some(bid.to_string());
+                    combined_ver.build_id = bid.to_string();
+                }
+                if !$wtc.worker_deployment_name.is_empty() {
+                    combined_ver.deployment_name = $wtc.worker_deployment_name.clone();
+                }
+                #[allow(deprecated)]
+                if !$wtc.worker_deployment_version.is_empty() {
+                    if let Ok(ver) = $wtc.worker_deployment_version.parse() {
+                        combined_ver = ver;
+                    }
+                }
+                if let Some(dv) = $wtc.deployment_version.as_ref() {
+                    combined_ver = dv.clone().into();
+                }
+                if !combined_ver.is_empty() {
+                    $me.current_wft_deployment_info = Some(combined_ver);
                 }
             }};
         }
@@ -599,13 +615,12 @@ impl WorkflowMachines {
             {
                 apply_wft_complete_data!(self, wtc);
             }
-            if peeked_events.peek().is_none() {
-                if let Some(wtc) = self
+            if peeked_events.peek().is_none()
+                && let Some(wtc) = self
                     .last_history_from_server
                     .peek_next_wft_completed(event.event_id)
-                {
-                    apply_wft_complete_data!(self, wtc);
-                }
+            {
+                apply_wft_complete_data!(self, wtc);
             }
         }
 
@@ -615,10 +630,10 @@ impl WorkflowMachines {
         }
         let replay_start = Instant::now();
 
-        if let Some(last_event) = events.last() {
-            if last_event.event_type == EventType::WorkflowTaskStarted as i32 {
-                self.next_started_event_id = last_event.event_id;
-            }
+        if let Some(last_event) = events.last()
+            && last_event.event_type == EventType::WorkflowTaskStarted as i32
+        {
+            self.next_started_event_id = last_event.event_id;
         }
 
         let mut update_admitted_event_messages = HashMap::<String, IncomingProtocolMessage>::new();
@@ -719,7 +734,7 @@ impl WorkflowMachines {
 
         // Needed to delay mutation of self until after we've iterated over peeked events.
         enum DelayedAction {
-            WakeLa(MachineKey, CompleteLocalActivityData),
+            WakeLa(MachineKey, Box<CompleteLocalActivityData>),
             ProtocolMessage(IncomingProtocolMessage),
         }
         let mut delayed_actions = vec![];
@@ -755,7 +770,7 @@ impl WorkflowMachines {
                     if let Ok(mk) =
                         self.get_machine_key(CommandID::LocalActivity(la_dat.marker_dat.seq))
                     {
-                        delayed_actions.push(DelayedAction::WakeLa(mk, la_dat));
+                        delayed_actions.push(DelayedAction::WakeLa(mk, Box::new(la_dat)));
                     } else {
                         self.local_activity_data.insert_peeked_marker(la_dat);
                     }
@@ -787,10 +802,10 @@ impl WorkflowMachines {
                     let mach = self.machine_mut(mk);
                     if let Machines::LocalActivityMachine(ref mut lam) = *mach {
                         if lam.will_accept_resolve_marker() {
-                            let resps = lam.try_resolve_with_dat(la_dat.into())?;
+                            let resps = lam.try_resolve_with_dat((*la_dat).into())?;
                             self.process_machine_responses(mk, resps)?;
                         } else {
-                            self.local_activity_data.insert_peeked_marker(la_dat);
+                            self.local_activity_data.insert_peeked_marker(*la_dat);
                         }
                     }
                 }
@@ -1704,13 +1719,11 @@ fn patch_marker_handling(
     fn skip_one_or_two_events(next_event: Option<&HistoryEvent>) -> Result<EventHandlingOutcome> {
         // Also ignore the subsequent upsert event if present
         let mut skip_next_event = false;
-        if let Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(
-            atts,
-        )) = next_event.and_then(|ne| ne.attributes.as_ref())
+        if let Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(atts)) =
+            next_event.and_then(|ne| ne.attributes.as_ref())
+            && let Some(ref sa) = atts.search_attributes
         {
-            if let Some(ref sa) = atts.search_attributes {
-                skip_next_event = sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY);
-            }
+            skip_next_event = sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY);
         }
 
         Ok(EventHandlingOutcome::SkipEvent { skip_next_event })

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

@@ -23,7 +23,7 @@ use futures_util::future::AbortHandle;
 use std::{
     collections::HashSet,
     mem,
-    ops::Add,
+    ops::{Add, Sub},
     rc::Rc,
     sync::{Arc, mpsc::Sender},
     time::{Duration, Instant},
@@ -40,7 +40,8 @@ use temporal_sdk_core_protos::{
         workflow_completion,
     },
     temporal::api::{
-        command::v1::command::Attributes as CmdAttribs, enums::v1::WorkflowTaskFailedCause,
+        command::v1::command::Attributes as CmdAttribs,
+        enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
         failure::v1::Failure,
     },
 };
@@ -295,10 +296,12 @@ impl ManagedRun {
         // Only record latency metrics if we genuinely reported to server
         if let WFTReportStatus::Reported {
             reset_last_started_to,
+            completion_time,
         } = report_status
         {
             if let Some(ot) = &retme {
-                self.metrics.wf_task_latency(ot.start_time.elapsed());
+                self.metrics
+                    .wf_task_latency(completion_time.sub(ot.start_time));
             }
             if let Some(id) = reset_last_started_to {
                 self.wfm.machines.reset_last_started_id(id);
@@ -372,6 +375,7 @@ impl ManagedRun {
         &mut self,
         mut commands: Vec<WFCommand>,
         used_flags: Vec<u32>,
+        versioning_behavior: VersioningBehavior,
         resp_chan: Option<oneshot::Sender<ActivationCompleteResult>>,
         is_forced_failure: bool,
     ) -> Result<RunUpdateAct, Box<NextPageReq>> {
@@ -448,6 +452,7 @@ impl ManagedRun {
                 used_flags,
                 resp_chan,
                 is_forced_failure,
+                versioning_behavior,
             };
 
             // Verify we can actually apply the next workflow task, which will happen as part of
@@ -618,6 +623,7 @@ impl ManagedRun {
                             metadata: None,
                         }],
                         vec![],
+                        VersioningBehavior::Unspecified, // Doesn't matter since we're failing wf
                         resp_chan,
                         true,
                     )
@@ -690,6 +696,7 @@ impl ManagedRun {
             has_pending_query: completion.has_pending_query,
             activation_was_eviction: completion.activation_was_eviction,
             is_forced_failure: completion.is_forced_failure,
+            versioning_behavior: completion.versioning_behavior,
         };
 
         self.wfm.machines.add_lang_used_flags(completion.used_flags);
@@ -772,17 +779,17 @@ impl ManagedRun {
     ) -> Result<Option<FulfillableActivationComplete>, RunUpdateErr> {
         debug!(resolution=?res, "Applying local resolution");
         self.wfm.notify_of_local_result(res)?;
-        if self.wfm.machines.outstanding_local_activity_count() == 0 {
-            if let Some(mut wait_dat) = self.waiting_on_la.take() {
-                // Cancel the heartbeat timeout
-                wait_dat.hb_timeout_handle.abort();
-                if let Some((completion_dat, resp_chan)) = wait_dat.completion_dat.take() {
-                    return Ok(Some(self.prepare_complete_resp(
-                        resp_chan,
-                        completion_dat,
-                        false,
-                    )));
-                }
+        if self.wfm.machines.outstanding_local_activity_count() == 0
+            && let Some(mut wait_dat) = self.waiting_on_la.take()
+        {
+            // Cancel the heartbeat timeout
+            wait_dat.hb_timeout_handle.abort();
+            if let Some((completion_dat, resp_chan)) = wait_dat.completion_dat.take() {
+                return Ok(Some(self.prepare_complete_resp(
+                    resp_chan,
+                    completion_dat,
+                    false,
+                )));
             }
         }
         Ok(None)
@@ -896,10 +903,9 @@ impl ManagedRun {
                 // If the wft was just a legacy query, still reply, otherwise we might try to
                 // reply to the task as if it were a task rather than a query.
                 && !self.pending_work_is_legacy_query()
+                && let Some(wft) = self.wft.as_mut()
             {
-                if let Some(wft) = self.wft.as_mut() {
-                    wft.pending_queries.clear();
-                }
+                wft.pending_queries.clear();
             }
 
             self.trying_to_evict = Some(info);
@@ -1007,7 +1013,8 @@ impl ManagedRun {
             }
             Err(fail) => {
                 self.am_broken = true;
-                let rur = if let Some(resp_chan) = fail.complete_resp_chan {
+
+                if let Some(resp_chan) = fail.complete_resp_chan {
                     // Automatically fail the workflow task in the event we couldn't update machines
                     let fail_cause = if matches!(&fail.source, WFMachinesError::Nondeterminism(_)) {
                         WorkflowTaskFailedCause::NonDeterministicError
@@ -1027,8 +1034,7 @@ impl ManagedRun {
                         run_id: self.run_id().to_owned(),
                         machines_err: fail.source,
                     })
-                };
-                rur
+                }
             }
         }
     }
@@ -1118,8 +1124,10 @@ impl ManagedRun {
                     Some(CmdAttribs::CompleteWorkflowExecutionCommandAttributes(_)) => {
                         self.metrics.wf_completed();
                     }
-                    Some(CmdAttribs::FailWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_failed();
+                    Some(CmdAttribs::FailWorkflowExecutionCommandAttributes(attrs)) => {
+                        if metrics::should_record_failure_metric(&attrs.failure) {
+                            self.metrics.wf_failed();
+                        }
                     }
                     Some(CmdAttribs::ContinueAsNewWorkflowExecutionCommandAttributes(_)) => {
                         self.metrics.wf_continued_as_new();
@@ -1139,6 +1147,7 @@ impl ManagedRun {
                     messages,
                     query_responses,
                     sdk_metadata: machines_wft_response.metadata_for_complete(),
+                    versioning_behavior: data.versioning_behavior,
                 },
             })
         } else {
@@ -1172,25 +1181,24 @@ impl ManagedRun {
         outcome: ActivationCompleteOutcome,
         chan: Option<oneshot::Sender<ActivationCompleteResult>>,
     ) {
-        if let Some(chan) = chan {
-            if chan
+        if let Some(chan) = chan
+            && chan
                 .send(ActivationCompleteResult {
                     outcome,
                     replaying: self.wfm.machines.replaying,
                 })
                 .is_err()
-            {
-                let warnstr = "The workflow task completer went missing! This likely indicates an \
+        {
+            let warnstr = "The workflow task completer went missing! This likely indicates an \
                                SDK bug, please report."
-                    .to_string();
-                warn!(run_id=%self.run_id(), "{}", warnstr);
-                self.request_eviction(RequestEvictMsg {
-                    run_id: self.run_id().to_string(),
-                    message: warnstr,
-                    reason: EvictionReason::Fatal,
-                    auto_reply_fail_tt: None,
-                });
-            }
+                .to_string();
+            warn!(run_id=%self.run_id(), "{}", warnstr);
+            self.request_eviction(RequestEvictMsg {
+                run_id: self.run_id().to_string(),
+                message: warnstr,
+                reason: EvictionReason::Fatal,
+                auto_reply_fail_tt: None,
+            });
         }
     }
 
@@ -1337,6 +1345,7 @@ struct CompletionDataForWFT {
     has_pending_query: bool,
     activation_was_eviction: bool,
     is_forced_failure: bool,
+    versioning_behavior: VersioningBehavior,
 }
 
 /// Manages an instance of a [WorkflowMachines], which is not thread-safe, as well as other data
@@ -1481,6 +1490,7 @@ struct RunActivationCompletion {
     /// Used to notify the worker when the completion is done processing and the completion can
     /// unblock. Must always be `Some` when initialized.
     resp_chan: Option<oneshot::Sender<ActivationCompleteResult>>,
+    versioning_behavior: VersioningBehavior,
 }
 #[derive(Debug, derive_more::From)]
 enum ActOrFulfill {