@temporalio/core-bridge 0.14.0 → 0.16.4

package/sdk-core/src/prototype_rust_sdk/workflow_context.rs

@@ -99,7 +99,7 @@ impl WfContext {
         self.am_cancelled
             .changed()
             .await
-            .expect("Cancelled send half not dropped")
+            .expect("Cancelled send half not dropped");
     }
 
     /// Request to create a timer
@@ -206,7 +206,7 @@ impl WfContext {
 
     /// Force a workflow task failure (EX: in order to retry on non-sticky queue)
     pub fn force_task_fail(&self, with: anyhow::Error) {
-        self.send(with.into())
+        self.send(with.into());
     }
 
     /// Request the cancellation of an external workflow. May resolve as a failure if the workflow
@@ -262,7 +262,7 @@ impl WfContext {
 
     /// Cancel any cancellable operation by ID
     fn cancel(&mut self, cancellable_id: CancellableID) {
-        self.send(RustWfCmd::Cancel(cancellable_id))
+        self.send(RustWfCmd::Cancel(cancellable_id));
     }
 
     fn send(&self, c: RustWfCmd) {
@@ -280,7 +280,7 @@ pub trait CancellableFuture<T>: Future<Output = T> {
 struct WFCommandFut<T, D> {
     _unused: PhantomData<T>,
     result_rx: oneshot::Receiver<UnblockEvent>,
-    other_dat: D,
+    other_dat: Option<D>,
 }
 impl<T> WFCommandFut<T, ()> {
     fn new() -> (Self, oneshot::Sender<UnblockEvent>) {
@@ -295,7 +295,7 @@ impl<T, D> WFCommandFut<T, D> {
             Self {
                 _unused: PhantomData,
                 result_rx: rx,
-                other_dat,
+                other_dat: Some(other_dat),
             },
             tx,
         )
@@ -310,9 +310,15 @@ where
     type Output = T;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.result_rx
-            .poll_unpin(cx)
-            .map(|x| Unblockable::unblock(x.unwrap(), &self.other_dat))
+        self.result_rx.poll_unpin(cx).map(|x| {
+            // SAFETY: Because we can only enter this section once the future has resolved, we
+            // know it will never be polled again, therefore consuming the option is OK.
+            let od = self
+                .other_dat
+                .take()
+                .expect("Other data must exist when resolving command future");
+            Unblockable::unblock(x.unwrap(), od)
+        })
     }
 }
 
@@ -348,10 +354,7 @@ where
     type Output = T;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.cmd_fut
-            .result_rx
-            .poll_unpin(cx)
-            .map(|x| Unblockable::unblock(x.unwrap(), &self.cmd_fut.other_dat))
+        self.cmd_fut.poll_unpin(cx)
     }
 }
 
@@ -460,21 +463,24 @@ pub struct ChildWorkflow {
     opts: ChildWorkflowOptions,
 }
 
+pub struct ChildWfCommon {
+    workflow_id: String,
+    result_future: CancellableWFCommandFut<ChildWorkflowResult, ()>,
+}
+
 pub struct PendingChildWorkflow {
-    pub(crate) child_wf_cmd_seq_num: u32,
     pub status: ChildWorkflowStartStatus,
-    pub wfid: String,
+    pub common: ChildWfCommon,
 }
 
 impl PendingChildWorkflow {
     /// Returns `None` if the child did not start successfully. The returned [StartedChildWorkflow]
     /// can be used to wait on, signal, or cancel the child workflow.
-    pub fn as_started(&self) -> Option<StartedChildWorkflow> {
-        match &self.status {
+    pub fn into_started(self) -> Option<StartedChildWorkflow> {
+        match self.status {
             ChildWorkflowStartStatus::Succeeded(s) => Some(StartedChildWorkflow {
-                child_wf_cmd_seq_num: self.child_wf_cmd_seq_num,
-                run_id: s.run_id.clone(),
-                workflow_id: self.wfid.clone(),
+                run_id: s.run_id,
+                common: self.common,
             }),
             _ => None,
         }
@@ -482,9 +488,8 @@ impl PendingChildWorkflow {
 }
 
 pub struct StartedChildWorkflow {
-    pub(crate) child_wf_cmd_seq_num: u32,
     pub run_id: String,
-    pub workflow_id: String,
+    common: ChildWfCommon,
 }
 
 impl ChildWorkflow {
@@ -492,10 +497,35 @@ impl ChildWorkflow {
     pub fn start(self, cx: &mut WfContext) -> impl CancellableFuture<PendingChildWorkflow> {
         let child_seq = cx.next_child_workflow_sequence_number;
         cx.next_child_workflow_sequence_number += 1;
-        let (cmd, unblocker) = CancellableWFCommandFut::new_with_dat(
-            CancellableID::ChildWorkflow(child_seq),
-            self.opts.workflow_id.clone(),
+        // Immediately create the command/future for the result, otherwise if the user does
+        // not await the result until *after* we receive an activation for it, there will be nothing
+        // to match when unblocking.
+        let cancel_seq = cx.next_cancel_external_wf_sequence_number;
+        cx.next_cancel_external_wf_sequence_number += 1;
+        let (result_cmd, unblocker) =
+            CancellableWFCommandFut::new(CancellableID::ExternalWorkflow {
+                seqnum: cancel_seq,
+                execution: NamespacedWorkflowExecution {
+                    workflow_id: self.opts.workflow_id.clone(),
+                    ..Default::default()
+                },
+                only_child: true,
+            });
+        cx.send(
+            CommandSubscribeChildWorkflowCompletion {
+                seq: child_seq,
+                unblocker,
+            }
+            .into(),
         );
+
+        let common = ChildWfCommon {
+            workflow_id: self.opts.workflow_id.clone(),
+            result_future: result_cmd,
+        };
+
+        let (cmd, unblocker) =
+            CancellableWFCommandFut::new_with_dat(CancellableID::ChildWorkflow(child_seq), common);
         cx.send(
             CommandCreateRequest {
                 cmd: self.opts.into_command(child_seq).into(),
@@ -503,38 +533,23 @@ impl ChildWorkflow {
             }
             .into(),
         );
+
         cmd
     }
 }
 
 impl StartedChildWorkflow {
-    /// Create a future that will wait until completion of this child workflow execution
-    pub fn result(&self, cx: &mut WfContext) -> impl CancellableFuture<ChildWorkflowResult> {
-        let cancel_seq = cx.next_cancel_external_wf_sequence_number;
-        cx.next_cancel_external_wf_sequence_number += 1;
-        let (cmd, unblocker) = CancellableWFCommandFut::new(CancellableID::ExternalWorkflow {
-            seqnum: cancel_seq,
-            execution: NamespacedWorkflowExecution {
-                workflow_id: self.workflow_id.clone(),
-                ..Default::default()
-            },
-            only_child: true,
-        });
-        cx.send(
-            CommandSubscribeChildWorkflowCompletion {
-                seq: self.child_wf_cmd_seq_num,
-                unblocker,
-            }
-            .into(),
-        );
-        cmd
+    /// Consumes self and returns a future that will wait until completion of this child workflow
+    /// execution
+    pub fn result(self) -> impl CancellableFuture<ChildWorkflowResult> {
+        self.common.result_future
     }
 
     /// Cancel the child workflow
     pub fn cancel(&self, cx: &mut WfContext) -> impl Future<Output = CancelExternalWfResult> {
         let target = NamespacedWorkflowExecution {
             namespace: cx.namespace().to_string(),
-            workflow_id: self.workflow_id.clone(),
+            workflow_id: self.common.workflow_id.clone(),
             ..Default::default()
         };
         cx.cancel_external(target)
@@ -547,7 +562,7 @@ impl StartedChildWorkflow {
         signal_name: impl Into<String>,
         payload: impl Into<Payload>,
     ) -> impl CancellableFuture<SignalExternalWfResult> {
-        let target = sig_we::Target::ChildWorkflowId(self.workflow_id.clone());
+        let target = sig_we::Target::ChildWorkflowId(self.common.workflow_id.clone());
         cx.send_signal_wf(signal_name, payload, target)
     }
 }

package/sdk-core/src/prototype_rust_sdk/workflow_future.rs

@@ -5,7 +5,7 @@ use crate::{
     },
     workflow::CommandID,
 };
-use anyhow::{bail, Context as AnyhowContext, Error};
+use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
 use futures::{future::BoxFuture, FutureExt};
 use parking_lot::RwLock;
@@ -113,7 +113,7 @@ pub struct WorkflowFuture {
 }
 
 impl WorkflowFuture {
-    fn unblock(&mut self, event: UnblockEvent) {
+    fn unblock(&mut self, event: UnblockEvent) -> Result<(), Error> {
         let cmd_id = match event {
             UnblockEvent::Timer(seq) => CommandID::Timer(seq),
             UnblockEvent::Activity(seq, _) => CommandID::Activity(seq),
@@ -124,10 +124,11 @@ impl WorkflowFuture {
         };
         let unblocker = self.command_status.remove(&cmd_id);
         unblocker
-            .expect("Command not found")
+            .ok_or_else(|| anyhow!("Command {:?} not found to unblock!", cmd_id))?
             .unblocker
             .send(event)
-            .unwrap();
+            .expect("Receive half of unblock channel must exist");
+        Ok(())
     }
 
     fn fail_wft(&self, run_id: String, fail: Error) {
@@ -163,27 +164,27 @@ impl WorkflowFuture {
                 Variant::StartWorkflow(_) => {
                     // TODO: Can assign randomness seed whenever needed
                 }
-                Variant::FireTimer(FireTimer { seq }) => self.unblock(UnblockEvent::Timer(seq)),
+                Variant::FireTimer(FireTimer { seq }) => self.unblock(UnblockEvent::Timer(seq))?,
                 Variant::ResolveActivity(ResolveActivity { seq, result }) => {
                     self.unblock(UnblockEvent::Activity(
                         seq,
                         Box::new(result.context("Activity must have result")?),
-                    ))
+                    ))?;
                 }
                 Variant::ResolveChildWorkflowExecutionStart(
                     ResolveChildWorkflowExecutionStart { seq, status },
                 ) => self.unblock(UnblockEvent::WorkflowStart(
                     seq,
                     Box::new(status.context("Workflow start must have status")?),
-                )),
+                ))?,
                 Variant::ResolveChildWorkflowExecution(ResolveChildWorkflowExecution {
                     seq,
                     result,
                 }) => self.unblock(UnblockEvent::WorkflowComplete(
                     seq,
                     Box::new(result.context("Child Workflow execution must have a result")?),
-                )),
-                Variant::UpdateRandomSeed(_) => {}
+                ))?,
+                Variant::UpdateRandomSeed(_) => (),
                 Variant::QueryWorkflow(_) => {
                     todo!()
                 }
@@ -208,10 +209,10 @@ impl WorkflowFuture {
                     self.ctx_shared.write().changes.insert(patch_id, true);
                 }
                 Variant::ResolveSignalExternalWorkflow(attrs) => {
-                    self.unblock(UnblockEvent::SignalExternal(attrs.seq, attrs.failure))
+                    self.unblock(UnblockEvent::SignalExternal(attrs.seq, attrs.failure))?;
                 }
                 Variant::ResolveRequestCancelExternalWorkflow(attrs) => {
-                    self.unblock(UnblockEvent::CancelExternal(attrs.seq, attrs.failure))
+                    self.unblock(UnblockEvent::CancelExternal(attrs.seq, attrs.failure))?;
                 }
 
                 Variant::RemoveFromCache(_) => {
@@ -301,7 +302,7 @@ impl Future for WorkflowFuture {
                                 ));
                                 // TODO: cancelled timer should not simply be unblocked, in the
                                 //   other SDKs this returns an error
-                                self.unblock(UnblockEvent::Timer(seq));
+                                self.unblock(UnblockEvent::Timer(seq))?;
                                 // Re-poll wf future since a timer is now unblocked
                                 res = self.inner.poll_unpin(cx);
                             }

package/sdk-core/src/prototype_rust_sdk.rs

@@ -12,7 +12,10 @@ pub use workflow_context::{
     ActivityOptions, CancellableFuture, ChildWorkflow, ChildWorkflowOptions, WfContext,
 };
 
-use crate::{prototype_rust_sdk::workflow_context::PendingChildWorkflow, Core};
+use crate::{
+    prototype_rust_sdk::workflow_context::{ChildWfCommon, PendingChildWorkflow},
+    Core,
+};
 use anyhow::{anyhow, bail};
 use futures::{future::BoxFuture, stream::FuturesUnordered, FutureExt, StreamExt};
 use std::{
@@ -219,12 +222,12 @@ pub type CancelExternalWfResult = Result<CancelExternalOk, Failure>;
 trait Unblockable {
     type OtherDat;
 
-    fn unblock(ue: UnblockEvent, od: &Self::OtherDat) -> Self;
+    fn unblock(ue: UnblockEvent, od: Self::OtherDat) -> Self;
 }
 
 impl Unblockable for TimerResult {
     type OtherDat = ();
-    fn unblock(ue: UnblockEvent, _: &Self::OtherDat) -> Self {
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::Timer(_) => TimerResult,
             _ => panic!("Invalid unblock event for timer"),
@@ -234,7 +237,7 @@ impl Unblockable for TimerResult {
 
 impl Unblockable for ActivityResult {
     type OtherDat = ();
-    fn unblock(ue: UnblockEvent, _: &Self::OtherDat) -> Self {
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::Activity(_, result) => *result,
             _ => panic!("Invalid unblock event for activity"),
@@ -244,13 +247,12 @@ impl Unblockable for ActivityResult {
 
 impl Unblockable for PendingChildWorkflow {
     // Other data here is workflow id
-    type OtherDat = String;
-    fn unblock(ue: UnblockEvent, od: &Self::OtherDat) -> Self {
+    type OtherDat = ChildWfCommon;
+    fn unblock(ue: UnblockEvent, od: Self::OtherDat) -> Self {
         match ue {
-            UnblockEvent::WorkflowStart(seq, result) => PendingChildWorkflow {
-                child_wf_cmd_seq_num: seq,
+            UnblockEvent::WorkflowStart(_, result) => Self {
                 status: *result,
-                wfid: od.clone(),
+                common: od,
             },
             _ => panic!("Invalid unblock event for child workflow start"),
         }
@@ -259,7 +261,7 @@ impl Unblockable for PendingChildWorkflow {
 
 impl Unblockable for ChildWorkflowResult {
     type OtherDat = ();
-    fn unblock(ue: UnblockEvent, _: &Self::OtherDat) -> Self {
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::WorkflowComplete(_, result) => *result,
             _ => panic!("Invalid unblock event for child workflow complete"),
@@ -269,14 +271,10 @@ impl Unblockable for ChildWorkflowResult {
 
 impl Unblockable for SignalExternalWfResult {
     type OtherDat = ();
-    fn unblock(ue: UnblockEvent, _: &Self::OtherDat) -> Self {
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::SignalExternal(_, maybefail) => {
-                if let Some(f) = maybefail {
-                    Err(f)
-                } else {
-                    Ok(SignalExternalOk)
-                }
+                maybefail.map_or(Ok(SignalExternalOk), Err)
             }
             _ => panic!("Invalid unblock event for signal external workflow result"),
         }
@@ -285,14 +283,10 @@ impl Unblockable for SignalExternalWfResult {
 
 impl Unblockable for CancelExternalWfResult {
     type OtherDat = ();
-    fn unblock(ue: UnblockEvent, _: &Self::OtherDat) -> Self {
+    fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::CancelExternal(_, maybefail) => {
-                if let Some(f) = maybefail {
-                    Err(f)
-                } else {
-                    Ok(CancelExternalOk)
-                }
+                maybefail.map_or(Ok(CancelExternalOk), Err)
             }
             _ => panic!("Invalid unblock event for signal external workflow result"),
         }
@@ -383,7 +377,7 @@ pub enum WfExitValue<T: Debug> {
     /// Confirm the workflow was cancelled (can be automatic in a more advanced iteration)
     #[from(ignore)]
     Cancelled,
-    /// TODO: Will go away once we have eviction confirmation
+    /// The run was evicted
     #[from(ignore)]
     Evicted,
     /// Finish with a result

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

@@ -360,16 +360,14 @@ impl AggregatorSelector for SDKAggSelector {
         if *descriptor.instrument_kind() == InstrumentKind::ValueRecorder {
             // Some recorders are just gauges
             match descriptor.name() {
-                STICKY_CACHE_SIZE_NAME => return Some(Arc::new(last_value())),
-                NUM_POLLERS_NAME => return Some(Arc::new(last_value())),
+                STICKY_CACHE_SIZE_NAME | NUM_POLLERS_NAME => return Some(Arc::new(last_value())),
                 _ => (),
             }
 
             // Other recorders will select their appropriate buckets
             let buckets = match descriptor.name() {
                 WF_E2E_LATENCY_NAME => WF_LATENCY_MS_BUCKETS,
-                WF_TASK_EXECUTION_LATENCY_NAME => WF_TASK_MS_BUCKETS,
-                WF_TASK_REPLAY_LATENCY_NAME => WF_TASK_MS_BUCKETS,
+                WF_TASK_EXECUTION_LATENCY_NAME | WF_TASK_REPLAY_LATENCY_NAME => WF_TASK_MS_BUCKETS,
                 WF_TASK_SCHED_TO_START_LATENCY_NAME | ACT_SCHED_TO_START_LATENCY_NAME => {
                     TASK_SCHED_TO_START_MS_BUCKETS
                 }

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

@@ -17,7 +17,7 @@ use opentelemetry::{
 };
 use opentelemetry_otlp::WithExportConfig;
 use parking_lot::{const_mutex, Mutex};
-use std::{collections::VecDeque, net::SocketAddr, ops::Deref, time::Duration};
+use std::{collections::VecDeque, net::SocketAddr, time::Duration};
 use tracing_subscriber::{layer::SubscriberExt, EnvFilter};
 use url::Url;
 
@@ -112,7 +112,7 @@ pub(crate) fn telemetry_init(opts: &TelemetryOptions) -> Result<(), anyhow::Erro
     std::thread::spawn(move || {
         let res = GLOBAL_TELEM_DAT.get_or_try_init::<_, anyhow::Error>(move || {
             // Ensure closure captures the mutex guard
-            let _ = guard.deref();
+            let _ = &*guard;
 
             let runtime = tokio::runtime::Builder::new_multi_thread()
                 .thread_name("telemetry")
@@ -120,13 +120,12 @@ pub(crate) fn telemetry_init(opts: &TelemetryOptions) -> Result<(), anyhow::Erro
                 .enable_all()
                 .build()?;
             let mut globaldat = GlobalTelemDat::default();
-            let mut am_forwarding_logs = false;
+            let am_forwarding_logs = opts.log_forwarding_level != LevelFilter::Off;
 
-            if opts.log_forwarding_level != LevelFilter::Off {
+            if am_forwarding_logs {
                 log::set_max_level(opts.log_forwarding_level);
                 globaldat.core_export_logger =
                     Some(CoreExportLogger::new(opts.log_forwarding_level));
-                am_forwarding_logs = true;
             }
 
             let filter_layer = EnvFilter::try_from_env(LOG_FILTER_ENV_VAR).or_else(|_| {
@@ -232,7 +231,7 @@ pub(crate) fn test_telem_console() {
         log_forwarding_level: LevelFilter::Off,
         prometheus_export_bind_address: None,
     })
-    .unwrap()
+    .unwrap();
 }
 
 #[allow(dead_code)] // Not always used, called to enable for debugging when needed
@@ -244,7 +243,7 @@ pub(crate) fn test_telem_collector() {
         log_forwarding_level: LevelFilter::Off,
         prometheus_export_bind_address: None,
     })
-    .unwrap()
+    .unwrap();
 }
 
 /// A trait for using [Display] on the contents of vecs, etc, which don't implement it.

package/sdk-core/src/test_help/canned_histories.rs

@@ -228,39 +228,9 @@ pub fn single_activity(activity_id: &str) -> TestHistoryBuilder {
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let scheduled_event_id = t.add_get_event_id(
-        EventType::ActivityTaskScheduled,
-        Some(
-            history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                ActivityTaskScheduledEventAttributes {
-                    activity_id: activity_id.to_string(),
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
-    let started_event_id = t.add_get_event_id(
-        EventType::ActivityTaskStarted,
-        Some(
-            history_event::Attributes::ActivityTaskStartedEventAttributes(
-                ActivityTaskStartedEventAttributes {
-                    scheduled_event_id,
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
-    t.add(
-        EventType::ActivityTaskCompleted,
-        history_event::Attributes::ActivityTaskCompletedEventAttributes(
-            ActivityTaskCompletedEventAttributes {
-                scheduled_event_id,
-                started_event_id,
-                // todo add the result payload
-                ..Default::default()
-            },
-        ),
-    );
+    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
+    let started_event_id = t.add_activity_task_started(scheduled_event_id);
+    t.add_activity_task_completed(scheduled_event_id, started_event_id, Default::default());
     t.add_workflow_task_scheduled_and_started();
     t
 }
@@ -278,28 +248,8 @@ pub fn single_failed_activity(activity_id: &str) -> TestHistoryBuilder {
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let scheduled_event_id = t.add_get_event_id(
-        EventType::ActivityTaskScheduled,
-        Some(
-            history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                ActivityTaskScheduledEventAttributes {
-                    activity_id: activity_id.to_string(),
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
-    let started_event_id = t.add_get_event_id(
-        EventType::ActivityTaskStarted,
-        Some(
-            history_event::Attributes::ActivityTaskStartedEventAttributes(
-                ActivityTaskStartedEventAttributes {
-                    scheduled_event_id,
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
+    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
+    let started_event_id = t.add_activity_task_started(scheduled_event_id);
     t.add(
         EventType::ActivityTaskFailed,
         history_event::Attributes::ActivityTaskFailedEventAttributes(
@@ -329,17 +279,7 @@ pub fn cancel_scheduled_activity(activity_id: &str, signal_id: &str) -> TestHist
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let scheduled_event_id = t.add_get_event_id(
-        EventType::ActivityTaskScheduled,
-        Some(
-            history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                ActivityTaskScheduledEventAttributes {
-                    activity_id: activity_id.to_string(),
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
+    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
     t.add_we_signaled(
         signal_id,
         vec![Payload {
@@ -375,17 +315,7 @@ pub fn scheduled_activity_timeout(activity_id: &str) -> TestHistoryBuilder {
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let scheduled_event_id = t.add_get_event_id(
-        EventType::ActivityTaskScheduled,
-        Some(
-            history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                ActivityTaskScheduledEventAttributes {
-                    activity_id: activity_id.to_string(),
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
+    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
     t.add(
         EventType::ActivityTaskTimedOut,
         history_event::Attributes::ActivityTaskTimedOutEventAttributes(
@@ -422,17 +352,7 @@ pub fn scheduled_cancelled_activity_timeout(
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let scheduled_event_id = t.add_get_event_id(
-        EventType::ActivityTaskScheduled,
-        Some(
-            history_event::Attributes::ActivityTaskScheduledEventAttributes(
-                ActivityTaskScheduledEventAttributes {
-                    activity_id: activity_id.to_string(),
-                    ..Default::default()
-                },
-            ),
-        ),
-    );
+    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
     t.add_we_signaled(
         signal_id,
         vec![Payload {
@@ -947,6 +867,7 @@ pub fn two_signals(sig_1_id: &str, sig_2_id: &str) -> TestHistoryBuilder {
 ///  x: EVENT_TYPE_TIMER_FIRED
 ///  x: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
 ///  x: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  x: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
 /// --- End repeat ---
 /// 4 + (num tasks - 1) * 4 + 1: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
 pub fn long_sequential_timers(num_tasks: usize) -> TestHistoryBuilder {
@@ -954,7 +875,7 @@ pub fn long_sequential_timers(num_tasks: usize) -> TestHistoryBuilder {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
 
-    for i in 1..num_tasks + 1 {
+    for i in 1..=num_tasks {
         let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
         t.add(
             EventType::TimerFired,
@@ -1201,13 +1122,16 @@ pub fn timer_then_continue_as_new(timer_id: &str) -> TestHistoryBuilder {
 /// 10: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
 /// 11: EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED
 pub fn timer_wf_cancel_req_cancelled(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_cancelled())
+    timer_cancel_req_then(timer_id, TestHistoryBuilder::add_cancelled)
 }
 pub fn timer_wf_cancel_req_completed(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_workflow_execution_completed())
+    timer_cancel_req_then(
+        timer_id,
+        TestHistoryBuilder::add_workflow_execution_completed,
+    )
 }
 pub fn timer_wf_cancel_req_failed(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_workflow_execution_failed())
+    timer_cancel_req_then(timer_id, TestHistoryBuilder::add_workflow_execution_failed)
 }
 
 ///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
@@ -1237,7 +1161,7 @@ pub fn timer_wf_cancel_req_do_another_timer_then_cancelled() -> TestHistoryBuild
             }),
         );
         t.add_full_wf_task();
-        t.add_cancelled()
+        t.add_cancelled();
     })
 }