@temporalio/core-bridge 1.12.0 → 1.12.2

package/sdk-core/core/src/worker/heartbeat.rs

@@ -0,0 +1,229 @@
+use crate::WorkerClient;
+use crate::abstractions::dbg_panic;
+use gethostname::gethostname;
+use parking_lot::Mutex;
+use prost_types::Duration as PbDuration;
+use std::sync::{Arc, OnceLock};
+use std::time::{Duration, SystemTime};
+use temporal_sdk_core_api::worker::WorkerConfig;
+use temporal_sdk_core_protos::temporal::api::worker::v1::{WorkerHeartbeat, WorkerHostInfo};
+use tokio::sync::Notify;
+use tokio::task::JoinHandle;
+use tokio::time::MissedTickBehavior;
+use uuid::Uuid;
+
+pub(crate) type HeartbeatFn = Box<dyn Fn() -> Option<WorkerHeartbeat> + Send + Sync>;
+
+pub(crate) struct WorkerHeartbeatManager {
+    heartbeat_handle: JoinHandle<()>,
+}
+
+impl WorkerHeartbeatManager {
+    pub(crate) fn new(
+        config: WorkerConfig,
+        identity: String,
+        heartbeat_fn: Arc<OnceLock<HeartbeatFn>>,
+        client: Arc<dyn WorkerClient>,
+    ) -> Self {
+        let sdk_name_and_ver = client.sdk_name_and_version();
+        let reset_notify = Arc::new(Notify::new());
+        let data = Arc::new(Mutex::new(WorkerHeartbeatData::new(
+            config,
+            identity,
+            sdk_name_and_ver,
+            reset_notify.clone(),
+        )));
+        let data_clone = data.clone();
+
+        let heartbeat_handle = tokio::spawn(async move {
+            let mut ticker = tokio::time::interval(data_clone.lock().heartbeat_interval);
+            ticker.set_missed_tick_behavior(MissedTickBehavior::Delay);
+            loop {
+                tokio::select! {
+                    _ = ticker.tick() => {
+                        let heartbeat = if let Some(heartbeat) = data_clone.lock().capture_heartbeat_if_needed() {
+                            heartbeat
+                        } else {
+                            continue
+                        };
+                        if let Err(e) = client.clone().record_worker_heartbeat(heartbeat).await {
+                            if matches!(
+                                e.code(),
+                                tonic::Code::Unimplemented
+                            ) {
+                                return;
+                            }
+                            warn!(error=?e, "Network error while sending worker heartbeat");
+                        }
+                    }
+                    _ = reset_notify.notified() => {
+                        ticker.reset();
+                    }
+                }
+            }
+        });
+
+        let data_clone = data.clone();
+        if heartbeat_fn
+            .set(Box::new(move || {
+                data_clone.lock().capture_heartbeat_if_needed()
+            }))
+            .is_err()
+        {
+            dbg_panic!(
+                "Failed to set heartbeat_fn, heartbeat_fn should only be set once, when a singular WorkerHeartbeatInfo is created"
+            );
+        }
+
+        Self { heartbeat_handle }
+    }
+
+    pub(crate) fn shutdown(&self) {
+        self.heartbeat_handle.abort()
+    }
+}
+
+#[derive(Debug, Clone)]
+struct WorkerHeartbeatData {
+    worker_instance_key: String,
+    worker_identity: String,
+    host_info: WorkerHostInfo,
+    // Time of the last heartbeat. This is used to both for heartbeat_time and last_heartbeat_time
+    heartbeat_time: Option<SystemTime>,
+    task_queue: String,
+    /// SDK name
+    sdk_name: String,
+    /// SDK version
+    sdk_version: String,
+    /// Worker start time
+    start_time: SystemTime,
+    heartbeat_interval: Duration,
+    reset_notify: Arc<Notify>,
+}
+
+impl WorkerHeartbeatData {
+    fn new(
+        worker_config: WorkerConfig,
+        worker_identity: String,
+        sdk_name_and_ver: (String, String),
+        reset_notify: Arc<Notify>,
+    ) -> Self {
+        Self {
+            worker_identity,
+            host_info: WorkerHostInfo {
+                host_name: gethostname().to_string_lossy().to_string(),
+                process_id: std::process::id().to_string(),
+                ..Default::default()
+            },
+            sdk_name: sdk_name_and_ver.0,
+            sdk_version: sdk_name_and_ver.1,
+            task_queue: worker_config.task_queue.clone(),
+            start_time: SystemTime::now(),
+            heartbeat_time: None,
+            worker_instance_key: Uuid::new_v4().to_string(),
+            heartbeat_interval: worker_config.heartbeat_interval,
+            reset_notify,
+        }
+    }
+
+    fn capture_heartbeat_if_needed(&mut self) -> Option<WorkerHeartbeat> {
+        let now = SystemTime::now();
+        let elapsed_since_last_heartbeat = if let Some(heartbeat_time) = self.heartbeat_time {
+            let dur = now.duration_since(heartbeat_time).unwrap_or(Duration::ZERO);
+
+            // Only send poll data if it's nearly been a full interval since this data has been sent
+            // In this case, "nearly" is 90% of the interval
+            if dur.as_secs_f64() < 0.9 * self.heartbeat_interval.as_secs_f64() {
+                return None;
+            }
+            Some(PbDuration {
+                seconds: dur.as_secs() as i64,
+                nanos: dur.subsec_nanos() as i32,
+            })
+        } else {
+            None
+        };
+
+        self.heartbeat_time = Some(now);
+
+        self.reset_notify.notify_one();
+
+        Some(WorkerHeartbeat {
+            worker_instance_key: self.worker_instance_key.clone(),
+            worker_identity: self.worker_identity.clone(),
+            host_info: Some(self.host_info.clone()),
+            task_queue: self.task_queue.clone(),
+            sdk_name: self.sdk_name.clone(),
+            sdk_version: self.sdk_version.clone(),
+            status: 0,
+            start_time: Some(self.start_time.into()),
+            heartbeat_time: Some(SystemTime::now().into()),
+            elapsed_since_last_heartbeat,
+            ..Default::default()
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_help::WorkerExt;
+    use crate::test_help::test_worker_cfg;
+    use crate::worker;
+    use crate::worker::client::mocks::mock_worker_client;
+    use std::sync::Arc;
+    use std::time::Duration;
+    use temporal_sdk_core_api::worker::PollerBehavior;
+    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::RecordWorkerHeartbeatResponse;
+
+    #[tokio::test]
+    async fn worker_heartbeat() {
+        let mut mock = mock_worker_client();
+        mock.expect_record_worker_heartbeat()
+            .times(2)
+            .returning(move |heartbeat| {
+                let host_info = heartbeat.host_info.clone().unwrap();
+                assert_eq!("test-identity", heartbeat.worker_identity);
+                assert!(!heartbeat.worker_instance_key.is_empty());
+                assert_eq!(
+                    host_info.host_name,
+                    gethostname::gethostname().to_string_lossy().to_string()
+                );
+                assert_eq!(host_info.process_id, std::process::id().to_string());
+                assert_eq!(heartbeat.sdk_name, "test-core");
+                assert_eq!(heartbeat.sdk_version, "0.0.0");
+                assert_eq!(heartbeat.task_queue, "q");
+                assert!(heartbeat.heartbeat_time.is_some());
+                assert!(heartbeat.start_time.is_some());
+
+                Ok(RecordWorkerHeartbeatResponse {})
+            });
+
+        let config = test_worker_cfg()
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
+            .max_outstanding_activities(1_usize)
+            .heartbeat_interval(Duration::from_millis(200))
+            .build()
+            .unwrap();
+
+        let heartbeat_fn = Arc::new(OnceLock::new());
+        let client = Arc::new(mock);
+        let worker = worker::Worker::new(config, None, client, None, Some(heartbeat_fn.clone()));
+        heartbeat_fn.get().unwrap()();
+
+        // heartbeat timer fires once
+        advance_time(Duration::from_millis(300)).await;
+        // it hasn't been >90% of the interval since the last heartbeat, so no data should be returned here
+        assert_eq!(None, heartbeat_fn.get().unwrap()());
+        // heartbeat timer fires once
+        advance_time(Duration::from_millis(300)).await;
+
+        worker.drain_activity_poller_and_shutdown().await;
+    }
+
+    async fn advance_time(dur: Duration) {
+        tokio::time::pause();
+        tokio::time::advance(dur).await;
+        tokio::time::resume();
+    }
+}

package/sdk-core/core/src/worker/mod.rs

@@ -1,5 +1,6 @@
 mod activities;
 pub(crate) mod client;
+mod heartbeat;
 mod nexus;
 mod slot_provider;
 pub(crate) mod tuner;
@@ -19,6 +20,7 @@ pub(crate) use activities::{
 pub(crate) use wft_poller::WFTPollerShared;
 pub(crate) use workflow::LEGACY_QUERY_ID;
 
+use crate::worker::heartbeat::{HeartbeatFn, WorkerHeartbeatManager};
 use crate::{
     ActivityHeartbeat, CompleteActivityError, PollError, WorkerTrait,
     abstractions::{MeteredPermitDealer, PermitDealerContextData, dbg_panic},
@@ -41,10 +43,15 @@ use crate::{
         },
     },
 };
+use crate::{
+    pollers::{ActivityTaskOptions, LongPollBuffer},
+    worker::workflow::wft_poller,
+};
 use activities::WorkerActivityTasks;
 use futures_util::{StreamExt, stream};
 use parking_lot::Mutex;
 use slot_provider::SlotProvider;
+use std::sync::OnceLock;
 use std::{
     convert::TryInto,
     future,
@@ -77,11 +84,6 @@ use temporal_sdk_core_protos::{
 use tokio::sync::{mpsc::unbounded_channel, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tokio_util::sync::CancellationToken;
-
-use crate::{
-    pollers::{ActivityTaskOptions, LongPollBuffer},
-    worker::workflow::wft_poller,
-};
 #[cfg(test)]
 use {
     crate::{
@@ -119,6 +121,8 @@ pub struct Worker {
     local_activities_complete: Arc<AtomicBool>,
     /// Used to track all permits have been released
     all_permits_tracker: tokio::sync::Mutex<AllPermitsTracker>,
+    /// Used to shutdown the worker heartbeat task
+    worker_heartbeat: Option<WorkerHeartbeatManager>,
 }
 
 struct AllPermitsTracker {
@@ -271,6 +275,7 @@ impl Worker {
         sticky_queue_name: Option<String>,
         client: Arc<dyn WorkerClient>,
         telem_instance: Option<&TelemetryInstance>,
+        heartbeat_fn: Option<Arc<OnceLock<HeartbeatFn>>>,
     ) -> Self {
         info!(task_queue=%config.task_queue, namespace=%config.namespace, "Initializing worker");
 
@@ -280,6 +285,7 @@ impl Worker {
             client,
             TaskPollers::Real,
             telem_instance,
+            heartbeat_fn,
         )
     }
 
@@ -297,7 +303,7 @@ impl Worker {
 
     #[cfg(test)]
     pub(crate) fn new_test(config: WorkerConfig, client: impl WorkerClient + 'static) -> Self {
-        Self::new(config, None, Arc::new(client), None)
+        Self::new(config, None, Arc::new(client), None, None)
     }
 
     pub(crate) fn new_with_pollers(
@@ -306,6 +312,7 @@ impl Worker {
         client: Arc<dyn WorkerClient>,
         task_pollers: TaskPollers,
         telem_instance: Option<&TelemetryInstance>,
+        heartbeat_fn: Option<Arc<OnceLock<HeartbeatFn>>>,
     ) -> Self {
         let (metrics, meter) = if let Some(ti) = telem_instance {
             (
@@ -325,7 +332,7 @@ impl Worker {
         let shutdown_token = CancellationToken::new();
         let slot_context_data = Arc::new(PermitDealerContextData {
             task_queue: config.task_queue.clone(),
-            worker_identity: config.client_identity_override.clone().unwrap_or_default(),
+            worker_identity: client.get_identity(),
             worker_deployment_version: config.computed_deployment_version(),
         });
         let wft_slots = MeteredPermitDealer::new(
@@ -437,17 +444,17 @@ impl Worker {
         };
 
         let (hb_tx, hb_rx) = unbounded_channel();
-        let la_pemit_dealer = MeteredPermitDealer::new(
+        let la_permit_dealer = MeteredPermitDealer::new(
             tuner.local_activity_slot_supplier(),
             metrics.with_new_attrs([local_activity_worker_type()]),
             None,
-            slot_context_data,
+            slot_context_data.clone(),
             meter.clone(),
         );
-        let la_permits = la_pemit_dealer.get_extant_count_rcv();
+        let la_permits = la_permit_dealer.get_extant_count_rcv();
         let local_act_mgr = Arc::new(LocalActivityManager::new(
             config.namespace.clone(),
-            la_pemit_dealer,
+            la_permit_dealer,
             hb_tx,
             metrics.clone(),
         ));
@@ -484,6 +491,16 @@ impl Worker {
         );
         let worker_key = Mutex::new(client.workers().register(Box::new(provider)));
         let sdk_name_and_ver = client.sdk_name_and_version();
+
+        let worker_heartbeat = heartbeat_fn.map(|heartbeat_fn| {
+            WorkerHeartbeatManager::new(
+                config.clone(),
+                client.get_identity(),
+                heartbeat_fn,
+                client.clone(),
+            )
+        });
+
         Self {
             worker_key,
             client: client.clone(),
@@ -540,6 +557,7 @@ impl Worker {
                 la_permits,
             }),
             nexus_mgr,
+            worker_heartbeat,
         }
     }
 
@@ -584,6 +602,9 @@ impl Worker {
                 dbg_panic!("Waiting for all slot permits to release took too long!");
             }
         }
+        if let Some(heartbeat) = self.worker_heartbeat.as_ref() {
+            heartbeat.shutdown();
+        }
     }
 
     /// Finish shutting down by consuming the background pollers and freeing all resources
@@ -883,7 +904,7 @@ mod tests {
     use crate::{
         advance_fut,
         test_help::test_worker_cfg,
-        worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
+        worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
     };
     use futures_util::FutureExt;
     use temporal_sdk_core_api::worker::PollerBehavior;
@@ -891,7 +912,7 @@ mod tests {
 
     #[tokio::test]
     async fn activity_timeouts_maintain_permit() {
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_poll_activity_task()
             .returning(|_, _| Ok(PollActivityTaskQueueResponse::default()));
@@ -913,7 +934,7 @@ mod tests {
     async fn activity_errs_dont_eat_permits() {
         // Return one error followed by simulating waiting on the poll, otherwise the poller will
         // loop very fast and be in some indeterminate state.
-        let mut mock_client = mock_manual_workflow_client();
+        let mut mock_client = mock_manual_worker_client();
         mock_client
             .expect_poll_activity_task()
             .returning(|_, _| async { Err(tonic::Status::internal("ahhh")) }.boxed())

package/sdk-core/core/src/worker/tuner/resource_based.rs

@@ -190,10 +190,10 @@ struct PidControllers {
 }
 struct MetricInstruments {
     attribs: MetricAttributes,
-    mem_usage: Arc<dyn GaugeF64>,
-    cpu_usage: Arc<dyn GaugeF64>,
-    mem_pid_output: Arc<dyn GaugeF64>,
-    cpu_pid_output: Arc<dyn GaugeF64>,
+    mem_usage: GaugeF64,
+    cpu_usage: GaugeF64,
+    mem_pid_output: GaugeF64,
+    cpu_pid_output: GaugeF64,
 }
 #[derive(Clone, Copy, Default)]
 struct LastMetricVals {

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

@@ -686,6 +686,7 @@ impl NextWFTSeqEndIndex {
 }
 
 /// Discovers the index of the last event in next WFT sequence within the passed-in slice
+/// For more on workflow task chunking, see arch_docs/workflow_task_chunking.md
 fn find_end_index_of_next_wft_seq(
     events: &[HistoryEvent],
     from_event_id: i64,
@@ -718,11 +719,6 @@ fn find_end_index_of_next_wft_seq(
             return NextWFTSeqEndIndex::Complete(last_index);
         }
 
-        // TODO: Emergency undo for boundary calculation change. Remove if no problems after a bit.
-        if std::env::var("TEMPORAL_NO_WFT_BOUNDARY_CHANGE").is_ok() {
-            saw_command = false;
-        }
-
         if e.event_type() == EventType::WorkflowTaskStarted {
             wft_started_event_id_to_index.push((e.event_id, ix));
             if let Some(next_event) = events.get(ix + 1) {
@@ -737,6 +733,9 @@ fn find_end_index_of_next_wft_seq(
                         | EventType::WorkflowExecutionTerminated
                         | EventType::WorkflowExecutionCanceled
                 ) {
+                    // Since we're skipping this WFT, we don't want to include it in the vec used
+                    // for update accepted sequencing lookups.
+                    wft_started_event_id_to_index.pop();
                     continue;
                 } else if next_event_type == EventType::WorkflowTaskCompleted {
                     if let Some(next_next_event) = events.get(ix + 2) {
@@ -761,7 +760,12 @@ fn find_end_index_of_next_wft_seq(
                                 ),
                             ) = next_next_event.attributes
                             {
-                                // Find index of closest WFT started before sequencing id
+                                // Find index of closest unskipped WFT started before sequencing id.
+                                // The fact that the WFT wasn't skipped is important. If it was, we
+                                // need to avoid stopping at that point even though that's where the
+                                // update was sequenced. If we did, we'll fail to actually include
+                                // the update accepted event and therefore fail to generate the
+                                // request to run the update handler on replay.
                                 if let Some(ret_ix) = wft_started_event_id_to_index
                                     .iter()
                                     .rev()
@@ -803,7 +807,7 @@ mod tests {
     use crate::{
         replay::{HistoryInfo, TestHistoryBuilder},
         test_help::{MockPollCfg, ResponseType, canned_histories, hist_to_poll_resp, mock_sdk_cfg},
-        worker::client::mocks::mock_workflow_client,
+        worker::client::mocks::mock_worker_client,
     };
     use futures_util::{StreamExt, TryStreamExt};
     use std::sync::atomic::{AtomicUsize, Ordering};
@@ -965,7 +969,7 @@ mod tests {
         let wft_started = hinfo.workflow_task_started_event_id();
         let full_hist = hinfo.into_events();
         let initial_hist = full_hist.chunks(chunk_size).next().unwrap().to_vec();
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
 
         let mut npt = 1;
         mock_client
@@ -1162,7 +1166,7 @@ mod tests {
         // Chop off the last event, which is WFT started, which server doesn't return in get
         // history
         history_from_get.history.as_mut().map(|h| h.events.pop());
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(history_from_get.clone()));
@@ -1220,7 +1224,7 @@ mod tests {
         let partial_task = timer_hist.get_one_wft(2).unwrap();
         let prev_started_wft_id = partial_task.previous_started_event_id();
         let wft_started_id = partial_task.workflow_task_started_event_id();
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(Default::default()));
@@ -1247,7 +1251,7 @@ mod tests {
         let wft_started_id = partial_task.workflow_task_started_event_id();
         let full_resp: GetWorkflowExecutionHistoryResponse =
             timer_hist.get_full_history_info().unwrap().into();
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| {
@@ -1296,7 +1300,7 @@ mod tests {
             timer_hist.get_full_history_info().unwrap().into();
         full_resp_with_npt.next_page_token = vec![1];
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(full_resp_with_npt.clone()))
@@ -1375,7 +1379,7 @@ mod tests {
         resp_1.next_page_token = vec![1];
         resp_1.history.as_mut().unwrap().events.truncate(4);
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(resp_1.clone()))
@@ -1486,7 +1490,7 @@ mod tests {
         t.add_we_signaled("hi", vec![]);
         t.add_workflow_task_scheduled_and_started();
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
 
         let events: Vec<HistoryEvent> = t.get_full_history_info().unwrap().into_events();
         let first_event = events[0].clone();
@@ -1602,7 +1606,7 @@ mod tests {
         let events: Vec<HistoryEvent> = t.get_full_history_info().unwrap().into_events();
         let first_event = events[0].clone();
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
 
         for (i, event) in events.into_iter().enumerate() {
             // Add an empty page
@@ -1722,7 +1726,7 @@ mod tests {
             t.get_full_history_info().unwrap().into();
         resp_1.next_page_token = vec![2];
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(resp_1.clone()))
@@ -1765,7 +1769,7 @@ mod tests {
         let workflow_task = t.get_full_history_info().unwrap();
         let prev_started_wft_id = workflow_task.previous_started_event_id();
         let wft_started_id = workflow_task.workflow_task_started_event_id();
-        let mock_client = mock_workflow_client();
+        let mock_client = mock_worker_client();
         let mut paginator = HistoryPaginator::new(
             workflow_task.into(),
             prev_started_wft_id,
@@ -1802,7 +1806,7 @@ mod tests {
         let full_resp: GetWorkflowExecutionHistoryResponse =
             t.get_full_history_info().unwrap().into();
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         mock_client
             .expect_get_workflow_execution_history()
             .returning(move |_, _, _| Ok(full_resp.clone()))
@@ -1839,7 +1843,7 @@ mod tests {
         let incremental_task =
             hist_to_poll_resp(&t, "wfid".to_owned(), ResponseType::OneTask(3)).resp;
 
-        let mut mock_client = mock_workflow_client();
+        let mut mock_client = mock_worker_client();
         let mut one_task_resp: GetWorkflowExecutionHistoryResponse =
             t.get_history_info(1).unwrap().into();
         one_task_resp.next_page_token = vec![1];
@@ -1877,4 +1881,52 @@ mod tests {
         let seq = next_check_peek(&mut update, 7);
         assert_eq!(seq.last().unwrap().event_id, 11);
     }
+
+    #[tokio::test]
+    async fn wft_fail_on_first_task_with_update() {
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_workflow_task_scheduled_and_started();
+        t.add_workflow_task_failed_with_failure(
+            WorkflowTaskFailedCause::Unspecified,
+            Default::default(),
+        );
+        t.add_full_wf_task();
+        let accept_id = t.add_update_accepted("1", "upd");
+        let timer_id = t.add_timer_started("1".to_string());
+        t.add_update_completed(accept_id);
+        t.add_timer_fired(timer_id, "1".to_string());
+        t.add_full_wf_task();
+
+        let mut update = t.as_history_update();
+        let seq = next_check_peek(&mut update, 0);
+        // In this case, we expect to see up to the task with update, since the task failure
+        // should be skipped. This means that the peek of the _next_ task will include the update
+        // and thus properly synthesize the update request with the first activation.
+        assert_eq!(seq.len(), 6);
+        let seq = next_check_peek(&mut update, 6);
+        assert_eq!(seq.len(), 7);
+    }
+
+    #[test]
+    fn update_accepted_after_empty_wft() {
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        t.add_full_wf_task();
+        let accept_id = t.add_update_accepted("1", "upd");
+        let timer_id = t.add_timer_started("1".to_string());
+        t.add_update_completed(accept_id);
+        t.add_timer_fired(timer_id, "1".to_string());
+        t.add_full_wf_task();
+
+        let mut update = t.as_history_update();
+        let seq = next_check_peek(&mut update, 0);
+        // unlike the case with a wft failure, here the first task should not extend through to
+        // the update, because here the first empty WFT happened with _just_ the workflow init,
+        // not also with the update.
+        assert_eq!(seq.len(), 3);
+        let seq = next_check_peek(&mut update, 3);
+        assert_eq!(seq.len(), 3);
+    }
 }

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

@@ -69,10 +69,9 @@ pub(super) fn new_external_cancel(
             namespace: workflow_execution.namespace,
             workflow_id: workflow_execution.workflow_id,
             run_id: workflow_execution.run_id,
-            // Apparently this is effectively deprecated at this point
-            control: "".to_string(),
             child_workflow_only: only_child,
             reason,
+            ..Default::default()
         },
     );
     NewMachineWithCommand {

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

@@ -714,7 +714,7 @@ impl WFMachinesAdapter for ChildWorkflowMachine {
                             run_id: self.shared_state.run_id.clone(),
                             child_workflow_only: true,
                             reason,
-                            control: "".to_string(),
+                            ..Default::default()
                         }
                         .into(),
                     ))