@temporalio/core-bridge 1.11.8 → 1.12.0

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

@@ -7,13 +7,10 @@ pub use resource_based::{
     ResourceSlotOptions,
 };
 
-use std::sync::{Arc, OnceLock};
-use temporal_sdk_core_api::{
-    telemetry::metrics::TemporalMeter,
-    worker::{
-        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotKind, SlotSupplier,
-        WorkerConfig, WorkerTuner, WorkflowSlotKind,
-    },
+use std::sync::Arc;
+use temporal_sdk_core_api::worker::{
+    ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotKind, SlotSupplier, WorkerConfig,
+    WorkerTuner, WorkflowSlotKind,
 };
 
 /// Allows for the composition of different slot suppliers into a [WorkerTuner]
@@ -22,7 +19,6 @@ pub struct TunerHolder {
     act_supplier: Arc<dyn SlotSupplier<SlotKind = ActivitySlotKind> + Send + Sync>,
     la_supplier: Arc<dyn SlotSupplier<SlotKind = LocalActivitySlotKind> + Send + Sync>,
     nexus_supplier: Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync>,
-    metrics: OnceLock<TemporalMeter>,
 }
 
 /// Can be used to construct a [TunerHolder] without needing to manually construct each
@@ -245,7 +241,6 @@ impl TunerBuilder {
                 .nexus_slot_supplier
                 .clone()
                 .unwrap_or_else(|| Arc::new(FixedSizeSlotSupplier::new(100))),
-            metrics: OnceLock::new(),
         }
     }
 }
@@ -274,8 +269,4 @@ impl WorkerTuner for TunerHolder {
     ) -> Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync> {
         self.nexus_supplier.clone()
     }
-
-    fn attach_metrics(&self, m: TemporalMeter) {
-        let _ = self.metrics.set(m);
-    }
 }

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

@@ -456,10 +456,10 @@ impl HistoryUpdate {
         use crate::abstractions::dbg_panic;
 
         for win in self.events.as_slice().windows(2) {
-            if let &[e1, e2] = &win {
-                if e2.event_id != e1.event_id + 1 {
-                    dbg_panic!("HistoryUpdate isn't contiguous! {:?} -> {:?}", e1, e2);
-                }
+            if let &[e1, e2] = &win
+                && e2.event_id != e1.event_id + 1
+            {
+                dbg_panic!("HistoryUpdate isn't contiguous! {:?} -> {:?}", e1, e2);
             }
         }
         true
@@ -632,10 +632,10 @@ impl HistoryUpdate {
     pub(crate) fn can_take_next_wft_sequence(&self, from_wft_started_id: i64) -> bool {
         let next_wft_ix =
             find_end_index_of_next_wft_seq(&self.events, from_wft_started_id, self.has_last_wft);
-        if let NextWFTSeqEndIndex::Incomplete(_) = next_wft_ix {
-            if !self.has_last_wft {
-                return false;
-            }
+        if let NextWFTSeqEndIndex::Incomplete(_) = next_wft_ix
+            && !self.has_last_wft
+        {
+            return false;
         }
         true
     }
@@ -695,7 +695,8 @@ fn find_end_index_of_next_wft_seq(
         return NextWFTSeqEndIndex::Incomplete(0);
     }
     let mut last_index = 0;
-    let mut saw_any_command_event = false;
+    let mut saw_command_or_started = false;
+    let mut saw_command = false;
     let mut wft_started_event_id_to_index = vec![];
     for (ix, e) in events.iter().enumerate() {
         last_index = ix;
@@ -706,13 +707,22 @@ fn find_end_index_of_next_wft_seq(
             continue;
         }
 
-        if e.is_command_event() || e.event_type() == EventType::WorkflowExecutionStarted {
-            saw_any_command_event = true;
+        if e.is_command_event() {
+            saw_command = true;
+            saw_command_or_started = true;
+        }
+        if e.event_type() == EventType::WorkflowExecutionStarted {
+            saw_command_or_started = true;
         }
         if e.is_final_wf_execution_event() {
             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) {
@@ -728,13 +738,14 @@ fn find_end_index_of_next_wft_seq(
                         | EventType::WorkflowExecutionCanceled
                 ) {
                     continue;
-                }
-                // If we've never seen an interesting event and the next two events are a completion
-                // followed immediately again by scheduled, then this is a WFT heartbeat and also
-                // doesn't conclude the sequence.
-                else if next_event_type == EventType::WorkflowTaskCompleted {
+                } else if next_event_type == EventType::WorkflowTaskCompleted {
                     if let Some(next_next_event) = events.get(ix + 2) {
-                        if next_next_event.event_type() == EventType::WorkflowTaskScheduled {
+                        if !saw_command
+                            && next_next_event.event_type() == EventType::WorkflowTaskScheduled
+                        {
+                            // If we've never seen an interesting event and the next two events are
+                            // a completion followed immediately again by scheduled, then this is a
+                            // WFT heartbeat and also doesn't conclude the sequence.
                             continue;
                         } else {
                             // If we see an update accepted command after WFT completed, we want to
@@ -766,18 +777,18 @@ fn find_end_index_of_next_wft_seq(
                             }
                             return NextWFTSeqEndIndex::Complete(ix);
                         }
-                    } else if !has_last_wft && !saw_any_command_event {
+                    } else if !has_last_wft && !saw_command_or_started {
                         // Don't have enough events to look ahead of the WorkflowTaskCompleted. Need
                         // to fetch more.
                         continue;
                     }
                 }
-            } else if !has_last_wft && !saw_any_command_event {
+            } else if !has_last_wft && !saw_command_or_started {
                 // Don't have enough events to look ahead of the WorkflowTaskStarted. Need to fetch
                 // more.
                 continue;
             }
-            if saw_any_command_event {
+            if saw_command_or_started {
                 return NextWFTSeqEndIndex::Complete(ix);
             }
         }
@@ -921,7 +932,9 @@ mod tests {
         let seq = next_check_peek(&mut update, 0);
         assert_eq!(seq.len(), 6);
         let seq = next_check_peek(&mut update, 6);
-        assert_eq!(seq.len(), 13);
+        assert_eq!(seq.len(), 4);
+        let seq = next_check_peek(&mut update, 10);
+        assert_eq!(seq.len(), 9);
         let seq = next_check_peek(&mut update, 19);
         assert_eq!(seq.len(), 4);
         let seq = next_check_peek(&mut update, 23);
@@ -1062,12 +1075,16 @@ mod tests {
         t
     }
 
+    #[rstest::rstest]
     #[tokio::test]
-    async fn needs_fetch_if_ending_in_middle_of_wft_seq() {
+    async fn needs_fetch_if_ending_in_middle_of_wft_seq(
+        // These values test points truncation could've occurred in the middle of the heartbeat
+        #[values(18, 19, 20, 21)] truncate_at: usize,
+    ) {
         let t = three_wfts_then_heartbeats();
         let mut ends_in_middle_of_seq = t.as_history_update().events;
-        ends_in_middle_of_seq.truncate(19);
-        // The update should contain the first two complete WFTs, ending on the 8th event which
+        ends_in_middle_of_seq.truncate(truncate_at);
+        // The update should contain the first three complete WFTs, ending on the 11th event which
         // is WFT started. The remaining events should be returned. False flags means the creator
         // knows there are more events, so we should return need fetch
         let (mut update, remaining) = HistoryUpdate::from_events(
@@ -1078,38 +1095,15 @@ mod tests {
                 .workflow_task_started_event_id(),
             false,
         );
-        assert_eq!(remaining[0].event_id, 8);
-        assert_eq!(remaining.last().unwrap().event_id, 19);
-        let seq = update.take_next_wft_sequence(0).unwrap_events();
-        assert_eq!(seq.last().unwrap().event_id, 3);
-        let seq = update.take_next_wft_sequence(3).unwrap_events();
-        assert_eq!(seq.last().unwrap().event_id, 7);
-        let next = update.take_next_wft_sequence(7);
-        assert_matches!(next, NextWFT::NeedFetch);
-    }
-
-    // Like the above, but if the history happens to be cut off at a wft boundary, (even though
-    // there may have been many heartbeats after we have no way of knowing about)
-    #[tokio::test]
-    async fn needs_fetch_after_complete_seq_with_heartbeats() {
-        let t = three_wfts_then_heartbeats();
-        let mut ends_in_middle_of_seq = t.as_history_update().events;
-        ends_in_middle_of_seq.truncate(20);
-        let (mut update, _) = HistoryUpdate::from_events(
-            ends_in_middle_of_seq,
-            0,
-            t.get_full_history_info()
-                .unwrap()
-                .workflow_task_started_event_id(),
-            false,
-        );
+        assert_eq!(remaining[0].event_id, 12);
+        assert_eq!(remaining.last().unwrap().event_id, truncate_at as i64);
         let seq = update.take_next_wft_sequence(0).unwrap_events();
         assert_eq!(seq.last().unwrap().event_id, 3);
         let seq = update.take_next_wft_sequence(3).unwrap_events();
         assert_eq!(seq.last().unwrap().event_id, 7);
         let seq = update.take_next_wft_sequence(7).unwrap_events();
-        assert_eq!(seq.last().unwrap().event_id, 20);
-        let next = update.take_next_wft_sequence(20);
+        assert_eq!(seq.last().unwrap().event_id, 11);
+        let next = update.take_next_wft_sequence(11);
         assert_matches!(next, NextWFT::NeedFetch);
     }
 
@@ -1146,6 +1140,8 @@ mod tests {
         let seq = update.take_next_wft_sequence(3).unwrap_events();
         assert_eq!(seq.last().unwrap().event_id, 7);
         let seq = update.take_next_wft_sequence(7).unwrap_events();
+        assert_eq!(seq.last().unwrap().event_id, 11);
+        let seq = update.take_next_wft_sequence(11).unwrap_events();
         assert_eq!(seq.last().unwrap().event_id, 158);
         let seq = update.take_next_wft_sequence(158).unwrap_events();
         assert_eq!(seq.last().unwrap().event_id, 160);

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

@@ -259,10 +259,7 @@ impl StartCommandCreated {
     ) -> ChildWorkflowMachineTransition<Cancelled> {
         state.cancelled_before_sent = true;
         ChildWorkflowMachineTransition::commands(vec![ChildWorkflowCommand::StartCancel(Failure {
-            message: format!(
-                "Child Workflow Execution cancelled before scheduled: {}",
-                reason
-            ),
+            message: format!("Child Workflow Execution cancelled before scheduled: {reason}"),
             cause: Some(Box::new(Failure {
                 failure_info: Some(FailureInfo::CanceledFailureInfo(
                     failure::CanceledFailureInfo {

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

@@ -9,7 +9,7 @@ use itertools::Itertools;
 use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use temporal_sdk_core_protos::{
     coresdk::{
-        nexus::{NexusOperationResult, nexus_operation_result},
+        nexus::{NexusOperationCancellationType, NexusOperationResult, nexus_operation_result},
         workflow_activation::{
             ResolveNexusOperation, ResolveNexusOperationStart, resolve_nexus_operation_start,
         },
@@ -51,9 +51,10 @@ fsm! {
     ScheduledEventRecorded
       --(NexusOperationTimedOut(NexusOperationTimedOutEventAttributes), on_timed_out)--> TimedOut;
     ScheduledEventRecorded
-      --(NexusOperationStarted(NexusOperationStartedEventAttributes), on_started)--> Started;
+      --(NexusOperationStarted(NexusOperationStartedEventAttributes), shared on_started)--> Started;
 
     Started --(Cancel, shared on_issue_cancel)--> Started;
+    Started --(Cancel, shared on_issue_cancel)--> Cancelled;
     Started --(CommandRequestCancelNexusOperation)--> Started;
     Started --(NexusOperationCancelRequested)--> Started;
     Started
@@ -65,17 +66,26 @@ fsm! {
     Started
       --(NexusOperationTimedOut(NexusOperationTimedOutEventAttributes), on_timed_out)--> TimedOut;
 
+    Cancelled --(Cancel)--> Cancelled;
+    Cancelled --(CommandRequestCancelNexusOperation)--> Cancelled;
+    Cancelled --(NexusOperationCancelRequested)--> Cancelled;
+    Cancelled --(NexusOperationCompleted(NexusOperationCompletedEventAttributes), shared on_completed)--> Cancelled;
+    Cancelled --(NexusOperationFailed(NexusOperationFailedEventAttributes), shared on_failed)--> Cancelled;
+    Cancelled --(NexusOperationTimedOut(NexusOperationTimedOutEventAttributes), shared on_timed_out)--> Cancelled;
+    Cancelled --(NexusOperationCanceled(NexusOperationCanceledEventAttributes))--> Cancelled;
+
     // Ignore cancels in all terminal states
     Completed --(Cancel)--> Completed;
     Failed --(Cancel)--> Failed;
-    Cancelled --(Cancel)--> Cancelled;
     TimedOut --(Cancel)--> TimedOut;
 }
 
 #[derive(Debug, derive_more::Display)]
 pub(super) enum NexusOperationCommand {
     #[display("Start")]
-    Start { operation_id: String },
+    Start { operation_token: String },
+    #[display("StartSync")]
+    StartSync,
     #[display("CancelBeforeStart")]
     CancelBeforeStart,
     #[display("Complete")]
@@ -100,6 +110,8 @@ pub(super) struct SharedState {
 
     cancelled_before_sent: bool,
     cancel_sent: bool,
+    cancel_type: NexusOperationCancellationType,
+    operation_token: Option<String>,
 }
 
 impl NexusOperationMachine {
@@ -114,6 +126,8 @@ impl NexusOperationMachine {
                 operation: attribs.operation.clone(),
                 cancelled_before_sent: false,
                 cancel_sent: false,
+                cancel_type: attribs.cancellation_type(),
+                operation_token: None,
             },
         );
         NewMachineWithCommand {
@@ -185,9 +199,7 @@ impl ScheduledEventRecorded {
         ca: NexusOperationCompletedEventAttributes,
     ) -> NexusOperationMachineTransition<Completed> {
         NexusOperationMachineTransition::commands([
-            NexusOperationCommand::Start {
-                operation_id: String::default(),
-            },
+            NexusOperationCommand::StartSync,
             NexusOperationCommand::Complete(ca.result),
         ])
     }
@@ -197,9 +209,7 @@ impl ScheduledEventRecorded {
         fa: NexusOperationFailedEventAttributes,
     ) -> NexusOperationMachineTransition<Failed> {
         NexusOperationMachineTransition::commands([
-            NexusOperationCommand::Start {
-                operation_id: String::default(),
-            },
+            NexusOperationCommand::StartSync,
             NexusOperationCommand::Fail(fa.failure.unwrap_or_else(|| Failure {
                 message: "Nexus operation failed but failure field was not populated".to_owned(),
                 ..Default::default()
@@ -212,9 +222,7 @@ impl ScheduledEventRecorded {
         ca: NexusOperationCanceledEventAttributes,
     ) -> NexusOperationMachineTransition<Cancelled> {
         NexusOperationMachineTransition::commands([
-            NexusOperationCommand::Start {
-                operation_id: String::default(),
-            },
+            NexusOperationCommand::StartSync,
             NexusOperationCommand::Cancel(ca.failure.unwrap_or_else(|| Failure {
                 message:
                     "Nexus operation was cancelled but failure field was not populated".to_owned(),
@@ -228,9 +236,7 @@ impl ScheduledEventRecorded {
         toa: NexusOperationTimedOutEventAttributes,
     ) -> NexusOperationMachineTransition<TimedOut> {
         NexusOperationMachineTransition::commands([
-            NexusOperationCommand::Start {
-                operation_id: String::default(),
-            },
+            NexusOperationCommand::StartSync,
             NexusOperationCommand::TimedOut(toa.failure.unwrap_or_else(|| Failure {
                 message: "Nexus operation timed out but failure field was not populated".to_owned(),
                 ..Default::default()
@@ -240,10 +246,12 @@ impl ScheduledEventRecorded {
 
     pub(super) fn on_started(
         self,
+        ss: &mut SharedState,
         sa: NexusOperationStartedEventAttributes,
     ) -> NexusOperationMachineTransition<Started> {
+        ss.operation_token = Some(sa.operation_token.clone());
         NexusOperationMachineTransition::commands([NexusOperationCommand::Start {
-            operation_id: sa.operation_id,
+            operation_token: sa.operation_token,
         }])
     }
 }
@@ -255,12 +263,20 @@ impl Started {
     pub(crate) fn on_issue_cancel(
         &self,
         ss: &mut SharedState,
-    ) -> NexusOperationMachineTransition<Started> {
+    ) -> NexusOperationMachineTransition<StartedOrCancelled> {
         if !ss.cancel_sent {
             ss.cancel_sent = true;
-            NexusOperationMachineTransition::commands([NexusOperationCommand::IssueCancel])
+            let dest = if matches!(
+                ss.cancel_type,
+                NexusOperationCancellationType::Abandon | NexusOperationCancellationType::TryCancel
+            ) {
+                StartedOrCancelled::Cancelled(Default::default())
+            } else {
+                StartedOrCancelled::Started(Default::default())
+            };
+            TransitionResult::ok([NexusOperationCommand::IssueCancel], dest)
         } else {
-            NexusOperationMachineTransition::default()
+            TransitionResult::ok([], StartedOrCancelled::Started(Default::default()))
         }
     }
 
@@ -321,6 +337,49 @@ pub(super) struct TimedOut;
 #[derive(Default, Clone)]
 pub(super) struct Cancelled;
 
+fn completion_of_not_abandoned_err() -> WFMachinesError {
+    WFMachinesError::Nondeterminism(
+        "Nexus operation which don't have the ABANDON cancellation type cannot complete after \
+         being cancelled."
+            .to_string(),
+    )
+}
+
+impl Cancelled {
+    pub(super) fn on_completed(
+        self,
+        ss: &mut SharedState,
+        _: NexusOperationCompletedEventAttributes,
+    ) -> NexusOperationMachineTransition<Cancelled> {
+        if ss.cancel_type == NexusOperationCancellationType::Abandon {
+            return NexusOperationMachineTransition::Err(completion_of_not_abandoned_err());
+        }
+        NexusOperationMachineTransition::ok([], self)
+    }
+
+    pub(super) fn on_failed(
+        self,
+        ss: &mut SharedState,
+        _: NexusOperationFailedEventAttributes,
+    ) -> NexusOperationMachineTransition<Cancelled> {
+        if ss.cancel_type == NexusOperationCancellationType::Abandon {
+            return NexusOperationMachineTransition::Err(completion_of_not_abandoned_err());
+        }
+        NexusOperationMachineTransition::ok([], self)
+    }
+
+    pub(super) fn on_timed_out(
+        self,
+        ss: &mut SharedState,
+        _: NexusOperationTimedOutEventAttributes,
+    ) -> NexusOperationMachineTransition<Cancelled> {
+        if ss.cancel_type == NexusOperationCancellationType::Abandon {
+            return NexusOperationMachineTransition::Err(completion_of_not_abandoned_err());
+        }
+        NexusOperationMachineTransition::ok([], self)
+    }
+}
+
 impl TryFrom<HistEventData> for NexusOperationMachineEvents {
     type Error = WFMachinesError;
 
@@ -412,12 +471,21 @@ impl WFMachinesAdapter for NexusOperationMachine {
         _: Option<EventInfo>,
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         Ok(match my_command {
-            NexusOperationCommand::Start { operation_id } => {
+            NexusOperationCommand::StartSync => {
                 vec![
                     ResolveNexusOperationStart {
                         seq: self.shared_state.lang_seq_num,
-                        status: Some(resolve_nexus_operation_start::Status::OperationId(
-                            operation_id,
+                        status: Some(resolve_nexus_operation_start::Status::StartedSync(true)),
+                    }
+                    .into(),
+                ]
+            }
+            NexusOperationCommand::Start { operation_token } => {
+                vec![
+                    ResolveNexusOperationStart {
+                        seq: self.shared_state.lang_seq_num,
+                        status: Some(resolve_nexus_operation_start::Status::OperationToken(
+                            operation_token,
                         )),
                     }
                     .into(),
@@ -430,6 +498,7 @@ impl WFMachinesAdapter for NexusOperationMachine {
                         status: Some(resolve_nexus_operation_start::Status::CancelledBeforeStart(
                             self.cancelled_failure(
                                 "Nexus Operation cancelled before scheduled".to_owned(),
+                                &self.shared_state.operation_token,
                             ),
                         )),
                     }
@@ -440,6 +509,7 @@ impl WFMachinesAdapter for NexusOperationMachine {
                             status: Some(nexus_operation_result::Status::Cancelled(
                                 self.cancelled_failure(
                                     "Nexus Operation cancelled before scheduled".to_owned(),
+                                    &self.shared_state.operation_token,
                                 ),
                             )),
                         }),
@@ -494,14 +564,39 @@ impl WFMachinesAdapter for NexusOperationMachine {
                 ]
             }
             NexusOperationCommand::IssueCancel => {
-                vec![MachineResponse::IssueNewCommand(
-                    command::Attributes::RequestCancelNexusOperationCommandAttributes(
-                        RequestCancelNexusOperationCommandAttributes {
-                            scheduled_event_id: self.shared_state.scheduled_event_id,
-                        },
+                let mut resps = vec![];
+                if self.shared_state.cancel_type != NexusOperationCancellationType::Abandon {
+                    resps.push(MachineResponse::IssueNewCommand(
+                        command::Attributes::RequestCancelNexusOperationCommandAttributes(
+                            RequestCancelNexusOperationCommandAttributes {
+                                scheduled_event_id: self.shared_state.scheduled_event_id,
+                            },
+                        )
+                        .into(),
+                    ))
+                }
+                // Immediately resolve abandon/trycancel modes
+                if matches!(
+                    self.shared_state.cancel_type,
+                    NexusOperationCancellationType::Abandon
+                        | NexusOperationCancellationType::TryCancel
+                ) {
+                    resps.push(
+                        ResolveNexusOperation {
+                            seq: self.shared_state.lang_seq_num,
+                            result: Some(NexusOperationResult {
+                                status: Some(nexus_operation_result::Status::Cancelled(
+                                    self.cancelled_failure(
+                                        "Nexus operation cancelled after starting".to_owned(),
+                                        &self.shared_state.operation_token,
+                                    ),
+                                )),
+                            }),
+                        }
+                        .into(),
                     )
-                    .into(),
-                )]
+                }
+                resps
             }
         })
     }
@@ -520,7 +615,7 @@ impl TryFrom<CommandType> for NexusOperationMachineEvents {
 }
 
 impl NexusOperationMachine {
-    fn cancelled_failure(&self, message: String) -> Failure {
+    fn cancelled_failure(&self, message: String, operation_token: &Option<String>) -> Failure {
         Failure {
             message,
             cause: Some(Box::new(Failure {
@@ -534,7 +629,7 @@ impl NexusOperationMachine {
                     service: self.shared_state.service.clone(),
                     operation: self.shared_state.operation.clone(),
                     operation_id: "".to_string(),
-                    operation_token: "".to_string(),
+                    operation_token: operation_token.clone().unwrap_or_default(),
                 },
             )),
             ..Default::default()

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

@@ -4,11 +4,10 @@
 //! never ever be removed from behind `#[cfg(test)]` compilation.
 
 use dashmap::{DashMap, DashSet, mapref::entry::Entry};
-use std::sync::LazyLock;
 use std::{
     path::PathBuf,
     sync::{
-        Mutex,
+        LazyLock, Mutex,
         mpsc::{SyncSender, sync_channel},
     },
     thread::JoinHandle,

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

@@ -173,7 +173,7 @@ impl UpdateMachine {
         msg: UpdateMsg,
     ) -> Result<MachineResponse, WFMachinesError> {
         let accept_body = msg.pack().map_err(|e| {
-            WFMachinesError::Fatal(format!("Failed to serialize update response: {:?}", e))
+            WFMachinesError::Fatal(format!("Failed to serialize update response: {e:?}"))
         })?;
         Ok(MachineResponse::IssueNewMessage(ProtocolMessage {
             id: outgoing_id.clone(),