@temporalio/core-bridge 1.10.3 → 1.11.1

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

@@ -25,17 +25,36 @@ use tokio::{sync::watch, task::JoinHandle};
 /// threshold for each, and slots are handed out if the output of both PID controllers is above some
 /// defined threshold. See [ResourceBasedSlotsOptions] for the default PID controller settings.
 pub struct ResourceBasedTuner<MI> {
-    slots: Arc<ResourceBasedSlots<MI>>,
+    slots: Arc<ResourceController<MI>>,
     wf_opts: Option<ResourceSlotOptions>,
     act_opts: Option<ResourceSlotOptions>,
     la_opts: Option<ResourceSlotOptions>,
 }
 
+impl ResourceBasedTuner<RealSysInfo> {
+    /// Create an instance attempting to target the provided memory and cpu thresholds as values
+    /// between 0 and 1.
+    pub fn new(target_mem_usage: f64, target_cpu_usage: f64) -> Self {
+        let opts = ResourceBasedSlotsOptionsBuilder::default()
+            .target_mem_usage(target_mem_usage)
+            .target_cpu_usage(target_cpu_usage)
+            .build()
+            .expect("default resource based slot options can't fail to build");
+        let controller = ResourceController::new_with_sysinfo(opts, RealSysInfo::new());
+        Self::new_from_controller(controller)
+    }
+
+    /// Create an instance using the fully configurable set of PID controller options
+    pub fn new_from_options(options: ResourceBasedSlotsOptions) -> Self {
+        let controller = ResourceController::new_with_sysinfo(options, RealSysInfo::new());
+        Self::new_from_controller(controller)
+    }
+}
+
 impl<MI> ResourceBasedTuner<MI> {
-    /// Build a new tuner from a [ResourceBasedSlots] instance
-    pub fn new(resourcer: ResourceBasedSlots<MI>) -> Self {
+    fn new_from_controller(controller: ResourceController<MI>) -> Self {
         Self {
-            slots: Arc::new(resourcer),
+            slots: Arc::new(controller),
             wf_opts: None,
             act_opts: None,
             la_opts: None,
@@ -84,23 +103,22 @@ pub struct ResourceSlotOptions {
     ramp_throttle: Duration,
 }
 
-/// Implements [SlotSupplier] and attempts to maintain certain levels of resource usage when
-/// under load.
-///
-/// It does so by using two PID controllers, one for memory and one for CPU, which are fed the
-/// current usage levels of their respective resource as measurements. The user specifies a target
-/// threshold for each, and slots are handed out if the output of both PID controllers is above some
-/// defined threshold. See [ResourceBasedSlotsOptions] for the default PID controller settings.
-pub struct ResourceBasedSlots<MI> {
+struct ResourceController<MI> {
     options: ResourceBasedSlotsOptions,
     sys_info_supplier: MI,
     metrics: OnceLock<JoinHandle<()>>,
     pids: Mutex<PidControllers>,
     last_metric_vals: Arc<AtomicCell<LastMetricVals>>,
 }
-/// Wraps [ResourceBasedSlots] for a specific slot type
-pub struct ResourceBasedSlotsForType<MI, SK> {
-    inner: Arc<ResourceBasedSlots<MI>>,
+/// Implements [SlotSupplier] and attempts to maintain certain levels of resource usage when under
+/// load.
+///
+/// It does so by using two PID controllers, one for memory and one for CPU, which are fed the
+/// current usage levels of their respective resource as measurements. The user specifies a target
+/// threshold for each, and slots are handed out if the output of both PID controllers is above some
+/// defined threshold. See [ResourceBasedSlotsOptions] for the default PID controller settings.
+pub(crate) struct ResourceBasedSlotsForType<MI, SK> {
+    inner: Arc<ResourceController<MI>>,
 
     opts: ResourceSlotOptions,
 
@@ -108,28 +126,35 @@ pub struct ResourceBasedSlotsForType<MI, SK> {
     last_slot_issued_rx: watch::Receiver<Instant>,
     _slot_kind: PhantomData<SK>,
 }
+/// Allows for the full customization of the PID options for a resource based tuner
 #[derive(Clone, Debug, derive_builder::Builder)]
 #[non_exhaustive]
 pub struct ResourceBasedSlotsOptions {
     /// A value in the range [0.0, 1.0] representing the target memory usage.
-    target_mem_usage: f64,
+    pub target_mem_usage: f64,
     /// A value in the range [0.0, 1.0] representing the target CPU usage.
-    target_cpu_usage: f64,
+    pub target_cpu_usage: f64,
 
+    /// See [pid::Pid::p]
     #[builder(default = "5.0")]
     pub mem_p_gain: f64,
+    /// See [pid::Pid::i]
     #[builder(default = "0.0")]
     pub mem_i_gain: f64,
+    /// See [pid::Pid::d]
     #[builder(default = "1.0")]
     pub mem_d_gain: f64,
     /// If the mem PID controller outputs a value higher than this, we say the mem half of things
     /// will allow a slot
     #[builder(default = "0.25")]
     pub mem_output_threshold: f64,
+    /// See [pid::Pid::d]
     #[builder(default = "5.0")]
     pub cpu_p_gain: f64,
+    /// See [pid::Pid::i]
     #[builder(default = "0.0")]
     pub cpu_i_gain: f64,
+    /// See [pid::Pid::d]
     #[builder(default = "1.0")]
     pub cpu_d_gain: f64,
     /// If the CPU PID controller outputs a value higher than this, we say the CPU half of things
@@ -156,24 +181,6 @@ struct LastMetricVals {
     cpu_used_percent: f64,
 }
 
-impl ResourceBasedSlots<RealSysInfo> {
-    /// Create an instance attempting to target the provided memory and cpu thresholds as values
-    /// between 0 and 1.
-    pub fn new(target_mem_usage: f64, target_cpu_usage: f64) -> Self {
-        let opts = ResourceBasedSlotsOptionsBuilder::default()
-            .target_mem_usage(target_mem_usage)
-            .target_cpu_usage(target_cpu_usage)
-            .build()
-            .expect("default resource based slot options can't fail to build");
-        Self::new_with_sysinfo(opts, RealSysInfo::new())
-    }
-
-    /// Create an instance using the fully configurable set of PID controller options
-    pub fn new_from_options(options: ResourceBasedSlotsOptions) -> Self {
-        Self::new_with_sysinfo(options, RealSysInfo::new())
-    }
-}
-
 impl PidControllers {
     fn new(options: &ResourceBasedSlotsOptions) -> Self {
         let mut mem = pid::Pid::new(options.target_mem_usage, 100.0);
@@ -272,19 +279,12 @@ where
     fn release_slot(&self) {}
 }
 
-impl<MI, SK> ResourceBasedSlotsForType<MI, SK>
-where
-    MI: Send + Sync + SystemResourceInfo,
-    SK: Send + SlotKind + Sync,
-{
-}
-
 impl<MI, SK> ResourceBasedSlotsForType<MI, SK>
 where
     MI: SystemResourceInfo + Send + Sync,
     SK: SlotKind + Send + Sync,
 {
-    fn new(inner: Arc<ResourceBasedSlots<MI>>, opts: ResourceSlotOptions) -> Self {
+    fn new(inner: Arc<ResourceController<MI>>, opts: ResourceSlotOptions) -> Self {
         let (tx, rx) = watch::channel(Instant::now());
         Self {
             opts,
@@ -334,7 +334,7 @@ impl<MI: SystemResourceInfo + Sync + Send + 'static> WorkerTuner for ResourceBas
     }
 }
 
-impl<MI: SystemResourceInfo + Sync + Send> ResourceBasedSlots<MI> {
+impl<MI: SystemResourceInfo + Sync + Send> ResourceController<MI> {
     /// Create a [ResourceBasedSlotsForType] for this instance which is willing to hand out
     /// `minimum` slots with no checks at all and `max` slots ever. Otherwise the underlying
     /// mem/cpu targets will attempt to be matched while under load.
@@ -344,7 +344,7 @@ impl<MI: SystemResourceInfo + Sync + Send> ResourceBasedSlots<MI> {
     /// where activities might use a lot of resources, because otherwise the implementation may
     /// hand out many slots quickly before resource usage has a chance to be reflected, possibly
     /// resulting in OOM (for example).
-    pub fn as_kind<SK: SlotKind + Send + Sync>(
+    pub(crate) fn as_kind<SK: SlotKind + Send + Sync>(
         self: &Arc<Self>,
         opts: ResourceSlotOptions,
     ) -> Arc<ResourceBasedSlotsForType<MI, SK>> {
@@ -506,7 +506,7 @@ mod tests {
     #[test]
     fn mem_workflow_sync() {
         let (fmis, used) = FakeMIS::new();
-        let rbs = Arc::new(ResourceBasedSlots::new_with_sysinfo(test_options(), fmis))
+        let rbs = Arc::new(ResourceController::new_with_sysinfo(test_options(), fmis))
             .as_kind::<WorkflowSlotKind>(ResourceSlotOptions {
             min_slots: 0,
             max_slots: 100,
@@ -522,7 +522,7 @@ mod tests {
     async fn mem_workflow_async() {
         let (fmis, used) = FakeMIS::new();
         used.store(90_000, Ordering::Release);
-        let rbs = Arc::new(ResourceBasedSlots::new_with_sysinfo(test_options(), fmis))
+        let rbs = Arc::new(ResourceController::new_with_sysinfo(test_options(), fmis))
             .as_kind::<WorkflowSlotKind>(ResourceSlotOptions {
             min_slots: 0,
             max_slots: 100,
@@ -546,7 +546,7 @@ mod tests {
     #[test]
     fn minimum_respected() {
         let (fmis, used) = FakeMIS::new();
-        let rbs = Arc::new(ResourceBasedSlots::new_with_sysinfo(test_options(), fmis))
+        let rbs = Arc::new(ResourceController::new_with_sysinfo(test_options(), fmis))
             .as_kind::<WorkflowSlotKind>(ResourceSlotOptions {
             min_slots: 2,
             max_slots: 100,

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

@@ -3,7 +3,8 @@ mod resource_based;
 
 pub use fixed_size::FixedSizeSlotSupplier;
 pub use resource_based::{
-    RealSysInfo, ResourceBasedSlots, ResourceBasedTuner, ResourceSlotOptions,
+    RealSysInfo, ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceBasedTuner,
+    ResourceSlotOptions,
 };
 
 use std::sync::{Arc, OnceLock};
@@ -23,6 +24,125 @@ pub struct TunerHolder {
     metrics: OnceLock<TemporalMeter>,
 }
 
+/// Can be used to construct a [TunerHolder] without needing to manually construct each
+/// [SlotSupplier]. Useful for lang bridges to allow more easily passing through user options.
+#[derive(Clone, Debug, derive_builder::Builder)]
+#[builder(build_fn(validate = "Self::validate"))]
+#[non_exhaustive]
+pub struct TunerHolderOptions {
+    /// Options for workflow slots
+    #[builder(default, setter(strip_option))]
+    pub workflow_slot_options: Option<SlotSupplierOptions>,
+    /// Options for activity slots
+    #[builder(default, setter(strip_option))]
+    pub activity_slot_options: Option<SlotSupplierOptions>,
+    /// Options for local activity slots
+    #[builder(default, setter(strip_option))]
+    pub local_activity_slot_options: Option<SlotSupplierOptions>,
+    /// Options that will apply to all resource based slot suppliers. Must be set if any slot
+    /// options are [SlotSupplierOptions::ResourceBased]
+    #[builder(default, setter(strip_option))]
+    pub resource_based_options: Option<ResourceBasedSlotsOptions>,
+}
+
+impl TunerHolderOptions {
+    /// Create a [TunerHolder] from these options
+    pub fn build_tuner_holder(self) -> Result<TunerHolder, anyhow::Error> {
+        let mut builder = TunerBuilder::default();
+        // safety note: unwraps here are OK since the builder validator guarantees options for
+        // a resource based tuner are present if any supplier is resource based
+        let mut rb_tuner = self
+            .resource_based_options
+            .map(ResourceBasedTuner::new_from_options);
+        match self.workflow_slot_options {
+            Some(SlotSupplierOptions::FixedSize { slots }) => {
+                builder.workflow_slot_supplier(Arc::new(FixedSizeSlotSupplier::new(slots)));
+            }
+            Some(SlotSupplierOptions::ResourceBased(rso)) => {
+                builder.workflow_slot_supplier(
+                    rb_tuner
+                        .as_mut()
+                        .unwrap()
+                        .with_workflow_slots_options(rso)
+                        .workflow_task_slot_supplier(),
+                );
+            }
+            None => {}
+        }
+        match self.activity_slot_options {
+            Some(SlotSupplierOptions::FixedSize { slots }) => {
+                builder.activity_slot_supplier(Arc::new(FixedSizeSlotSupplier::new(slots)));
+            }
+            Some(SlotSupplierOptions::ResourceBased(rso)) => {
+                builder.activity_slot_supplier(
+                    rb_tuner
+                        .as_mut()
+                        .unwrap()
+                        .with_activity_slots_options(rso)
+                        .activity_task_slot_supplier(),
+                );
+            }
+            None => {}
+        }
+        match self.local_activity_slot_options {
+            Some(SlotSupplierOptions::FixedSize { slots }) => {
+                builder.local_activity_slot_supplier(Arc::new(FixedSizeSlotSupplier::new(slots)));
+            }
+            Some(SlotSupplierOptions::ResourceBased(rso)) => {
+                builder.local_activity_slot_supplier(
+                    rb_tuner
+                        .as_mut()
+                        .unwrap()
+                        .with_local_activity_slots_options(rso)
+                        .local_activity_slot_supplier(),
+                );
+            }
+            None => {}
+        }
+        Ok(builder.build())
+    }
+}
+
+/// Options for known kinds of slot suppliers
+#[derive(Clone, Debug)]
+pub enum SlotSupplierOptions {
+    /// Options for a [FixedSizeSlotSupplier]
+    FixedSize {
+        /// The number of slots the fixed supplier will have
+        slots: usize,
+    },
+    /// Options for a [ResourceBasedSlots]
+    ResourceBased(ResourceSlotOptions),
+}
+
+impl TunerHolderOptionsBuilder {
+    /// Create a [TunerHolder] from this builder
+    pub fn build_tuner_holder(self) -> Result<TunerHolder, anyhow::Error> {
+        let s = self.build()?;
+        s.build_tuner_holder()
+    }
+
+    fn validate(&self) -> Result<(), String> {
+        let any_is_resource_based = matches!(
+            self.workflow_slot_options,
+            Some(Some(SlotSupplierOptions::ResourceBased(_)))
+        ) || matches!(
+            self.activity_slot_options,
+            Some(Some(SlotSupplierOptions::ResourceBased(_)))
+        ) || matches!(
+            self.local_activity_slot_options,
+            Some(Some(SlotSupplierOptions::ResourceBased(_)))
+        );
+        if any_is_resource_based && matches!(self.resource_based_options, None | Some(None)) {
+            return Err(
+                "`resource_based_options` must be set if any slot options are ResourceBased"
+                    .to_string(),
+            );
+        }
+        Ok(())
+    }
+}
+
 /// Can be used to construct a `TunerHolder` from individual slot suppliers. Any supplier which is
 /// not provided will default to a [FixedSizeSlotSupplier] with a capacity of 100.
 #[derive(Default, Clone)]
@@ -78,8 +198,8 @@ impl TunerBuilder {
     }
 
     /// Build a [WorkerTuner] from the configured slot suppliers
-    pub fn build(&mut self) -> Arc<dyn WorkerTuner + Send + Sync> {
-        Arc::new(TunerHolder {
+    pub fn build(&mut self) -> TunerHolder {
+        TunerHolder {
             wft_supplier: self
                 .workflow_slot_supplier
                 .clone()
@@ -93,7 +213,7 @@ impl TunerBuilder {
                 .clone()
                 .unwrap_or_else(|| Arc::new(FixedSizeSlotSupplier::new(100))),
             metrics: OnceLock::new(),
-        })
+        }
     }
 }
 

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

@@ -41,7 +41,7 @@ impl DrivenWorkflow {
     ) {
         debug!(run_id = %attribs.original_execution_run_id, "Driven WF start");
         let started_info = WorkflowStartedInfo {
-            workflow_task_timeout: attribs.workflow_task_timeout.clone().try_into_or_none(),
+            workflow_task_timeout: attribs.workflow_task_timeout.try_into_or_none(),
             memo: attribs.memo.clone(),
             search_attrs: attribs.search_attributes.clone(),
             retry_policy: attribs.retry_policy.clone(),

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

@@ -5,7 +5,7 @@ use crate::{
         workflow::{CacheMissFetchReq, PermittedWFT, PreparedWFT},
     },
 };
-use futures::{future::BoxFuture, FutureExt, Stream};
+use futures::{future::BoxFuture, FutureExt, Stream, TryFutureExt};
 use itertools::Itertools;
 use once_cell::sync::Lazy;
 use std::{
@@ -65,6 +65,12 @@ impl Debug for HistoryUpdate {
     }
 }
 
+impl HistoryUpdate {
+    pub(crate) fn get_events(&self) -> &[HistoryEvent] {
+        &self.events
+    }
+}
+
 #[derive(Debug)]
 pub(crate) enum NextWFT {
     ReplayOver,
@@ -402,7 +408,10 @@ impl Stream for StreamingHistoryPaginator {
             // SAFETY: This is safe because the inner paginator cannot be dropped before the future,
             //   and the future won't be moved from out of this struct.
             this.open_history_request.set(Some(unsafe {
-                transmute(HistoryPaginator::get_next_page(this.inner).boxed())
+                transmute::<
+                    BoxFuture<'_, Result<(), tonic::Status>>,
+                    BoxFuture<'static, Result<(), tonic::Status>>,
+                >(this.inner.get_next_page().map_ok(|_| ()).boxed())
             }));
         }
         let history_req = this.open_history_request.as_mut().as_pin_mut().unwrap();

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

@@ -134,6 +134,7 @@ impl ActivityMachine {
                 s.shared_state().attrs.clone(),
                 use_compatible_version,
             )),
+            user_metadata: Default::default(),
         };
         NewMachineWithCommand {
             command,
@@ -406,7 +407,7 @@ impl ScheduleCommandCreated {
 
     pub(super) fn on_abandoned(self, dat: &mut SharedState) -> ActivityMachineTransition<Canceled> {
         dat.cancelled_before_sent = true;
-        ActivityMachineTransition::default()
+        notify_lang_activity_cancelled(None)
     }
 }
 
@@ -687,6 +688,7 @@ where
                 },
             ),
         ),
+        user_metadata: Default::default(),
     };
     ActivityMachineTransition::ok(
         vec![ActivityMachineCommand::RequestCancellation(cmd)],
@@ -804,7 +806,7 @@ mod test {
         internal_flags::InternalFlags,
         replay::TestHistoryBuilder,
         test_help::{build_fake_sdk, MockPollCfg, ResponseType},
-        worker::workflow::machines::Machines,
+        worker::workflow::{machines::Machines, OutgoingJob},
     };
     use std::{cell::RefCell, mem::discriminant, rc::Rc};
     use temporal_sdk::{ActivityOptions, CancellableFuture, WfContext, WorkflowFunction};
@@ -903,7 +905,20 @@ mod test {
             panic!("Wrong machine type");
         };
         let cmds = s.cancel().unwrap();
-        assert_eq!(cmds.len(), 0);
+        // We should always be notifying lang that the activity got cancelled, even if it's
+        // abandoned and we aren't telling server
+        assert_matches!(
+            cmds.as_slice(),
+            [MachineResponse::PushWFJob(OutgoingJob {
+                variant: workflow_activation_job::Variant::ResolveActivity(ResolveActivity {
+                    result: Some(ActivityResolution {
+                        status: Some(activity_resolution::Status::Cancelled(_))
+                    }),
+                    ..
+                }),
+                ..
+            })]
+        );
         let curstate = s.state();
         assert!(matches!(curstate, &ActivityMachineState::Canceled(_)));
     }

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

@@ -78,6 +78,7 @@ pub(super) fn new_external_cancel(
     let cmd = Command {
         command_type: CommandType::RequestCancelExternalWorkflowExecution as i32,
         attributes: Some(cmd_attrs),
+        user_metadata: Default::default(),
     };
     NewMachineWithCommand {
         command: cmd,

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

@@ -37,6 +37,7 @@ pub(super) fn cancel_workflow(attribs: CancelWorkflowExecution) -> NewMachineWit
     let command = Command {
         command_type: CommandType::CancelWorkflowExecution as i32,
         attributes: Some(attribs.into()),
+        user_metadata: Default::default(),
     };
     NewMachineWithCommand {
         command,

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

@@ -457,6 +457,7 @@ impl ChildWorkflowMachine {
                 attribs,
                 use_compatible_version,
             )),
+            user_metadata: Default::default(),
         };
         NewMachineWithCommand {
             command: cmd,

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

@@ -97,6 +97,7 @@ impl Created {
         let cmd = Command {
             command_type: CommandType::CompleteWorkflowExecution as i32,
             attributes: Some(self.attribs.into()),
+            user_metadata: Default::default(),
         };
         TransitionResult::commands(vec![CompleteWFCommand::AddCommand(cmd)])
     }

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

@@ -40,6 +40,7 @@ pub(super) fn continue_as_new(
     let command = Command {
         command_type: CommandType::ContinueAsNewWorkflowExecution as i32,
         attributes: Some(continue_as_new_cmd_to_api(attribs, use_compatible_version)),
+        user_metadata: Default::default(),
     };
     NewMachineWithCommand {
         command,

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

@@ -64,6 +64,7 @@ impl Created {
         let cmd = ProtoCommand {
             command_type: CommandType::FailWorkflowExecution as i32,
             attributes: Some(self.attribs.into()),
+            user_metadata: Default::default(),
         };
         TransitionResult::commands(vec![FailWFCommand::AddCommand(cmd)])
     }

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

@@ -674,7 +674,7 @@ impl WFMachinesAdapter for LocalActivityMachine {
                         status: Some(
                             DoBackoff {
                                 attempt: attempt + 1,
-                                backoff_duration: Some(b.clone()),
+                                backoff_duration: Some(*b),
                                 original_schedule_time: original_schedule_time.map(Into::into),
                             }
                             .into(),
@@ -882,7 +882,7 @@ mod tests {
         time::Duration,
     };
     use temporal_sdk::{
-        ActContext, ActivityCancelledError, CancellableFuture, LocalActivityOptions, WfContext,
+        ActContext, ActivityError, CancellableFuture, LocalActivityOptions, WfContext,
         WorkflowResult,
     };
     use temporal_sdk_core_protos::{
@@ -988,7 +988,7 @@ mod tests {
                 if completes_ok {
                     Ok("hi")
                 } else {
-                    Err(anyhow!("Oh no I failed!"))
+                    Err(anyhow!("Oh no I failed!").into())
                 }
             },
         );
@@ -1450,7 +1450,7 @@ mod tests {
                     ctx.cancelled().await;
                 }
                 allow_cancel_barr_clone.cancelled().await;
-                Result::<(), _>::Err(anyhow!(ActivityCancelledError::default()))
+                Result::<(), _>::Err(ActivityError::cancelled())
             }
         });
         worker.run().await.unwrap();

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

@@ -31,6 +31,7 @@ pub(super) fn modify_workflow_properties(
     let cmd = Command {
         command_type: CommandType::ModifyWorkflowProperties as i32,
         attributes: Some(lang_cmd.into()),
+        user_metadata: Default::default(),
     };
     NewMachineWithCommand {
         command: cmd,

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

@@ -114,6 +114,7 @@ pub(super) fn has_change<'a>(
             }
             .into(),
         ),
+        user_metadata: Default::default(),
     };
     let mut machine = PatchMachine::from_parts(initial_state, shared_state);
 

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

@@ -112,6 +112,7 @@ pub(super) fn new_external_signal(
     let cmd = Command {
         command_type: CommandType::SignalExternalWorkflowExecution as i32,
         attributes: Some(cmd_attrs),
+        user_metadata: Default::default(),
     };
     Ok(NewMachineWithCommand {
         command: cmd,

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

@@ -78,7 +78,8 @@ impl TimerMachine {
             .expect("Scheduling timers doesn't fail");
         let cmd = Command {
             command_type: CommandType::StartTimer as i32,
-            attributes: Some(s.shared_state().attrs.clone().into()),
+            attributes: Some(s.shared_state().attrs.into()),
+            user_metadata: Default::default(),
         };
         (s, cmd)
     }
@@ -210,6 +211,7 @@ impl StartCommandRecorded {
         let cmd = Command {
             command_type: CommandType::CancelTimer as i32,
             attributes: Some(CancelTimer { seq: dat.attrs.seq }.into()),
+            user_metadata: Default::default(),
         };
         TransitionResult::ok(
             vec![TimerMachineCommand::IssueCancelCmd(cmd)],