temporalio 0.0.1 → 0.0.2

data/bridge/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -12,7 +12,7 @@ use super::{
     patch_state_machine::has_change, signal_external_state_machine::new_external_signal,
     timer_state_machine::new_timer, upsert_search_attributes_state_machine::upsert_search_attrs,
     workflow_machines::local_acts::LocalActivityData,
-    workflow_task_state_machine::WorkflowTaskMachine, MachineKind, Machines, NewMachineWithCommand,
+    workflow_task_state_machine::WorkflowTaskMachine, Machines, NewMachineWithCommand,
     TemporalStateMachine,
 };
 use crate::{
@@ -20,8 +20,9 @@ use crate::{
     telemetry::{metrics::MetricsContext, VecDisplayer},
     worker::{
         workflow::{
-            CommandID, DrivenWorkflow, HistoryUpdate, LocalResolution, WFCommand, WorkflowFetcher,
-            WorkflowStartedInfo,
+            machines::modify_workflow_properties_state_machine::modify_workflow_properties,
+            CommandID, DrivenWorkflow, HistoryUpdate, LocalResolution, OutgoingJob, WFCommand,
+            WorkflowFetcher, WorkflowStartedInfo,
         },
         ExecutingLAId, LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
     },
@@ -38,6 +39,7 @@ use std::{
 use temporal_sdk_core_protos::{
     coresdk::{
         common::NamespacedWorkflowExecution,
+        workflow_activation,
         workflow_activation::{
             workflow_activation_job, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation,
         },
@@ -153,9 +155,9 @@ struct ChangeInfo {
 #[derive(Debug, derive_more::Display)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
-pub enum MachineResponse {
+pub(super) enum MachineResponse {
     #[display(fmt = "PushWFJob({})", "_0")]
-    PushWFJob(workflow_activation_job::Variant),
+    PushWFJob(OutgoingJob),
 
     /// Pushes a new command into the list that will be sent to server once we respond with the
     /// workflow task completion
@@ -196,7 +198,7 @@ where
     T: Into<workflow_activation_job::Variant>,
 {
     fn from(v: T) -> Self {
-        Self::PushWFJob(v.into())
+        Self::PushWFJob(v.into().into())
     }
 }
 
@@ -315,6 +317,148 @@ impl WorkflowMachines {
         self.drive_me.get_started_info()
     }
 
+    /// Fetches commands which are ready for processing from the state machines, generally to be
+    /// sent off to the server. They are not removed from the internal queue, that happens when
+    /// corresponding history events from the server are being handled.
+    pub(crate) fn get_commands(&self) -> Vec<ProtoCommand> {
+        self.commands
+            .iter()
+            .filter_map(|c| {
+                if !self.machine(c.machine).is_final_state() {
+                    match &c.command {
+                        MachineAssociatedCommand::Real(cmd) => Some((**cmd).clone()),
+                        MachineAssociatedCommand::FakeLocalActivityMarker(_) => None,
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    /// Returns the next activation that needs to be performed by the lang sdk. Things like unblock
+    /// timer, etc. This does *not* cause any advancement of the state machines, it merely drains
+    /// from the outgoing queue of activation jobs.
+    ///
+    /// The job list may be empty, in which case it is expected the caller handles what to do in a
+    /// "no work" situation. Possibly, it may know about some work the machines don't, like queries.
+    pub(crate) fn get_wf_activation(&mut self) -> WorkflowActivation {
+        let jobs = self.drive_me.drain_jobs();
+        WorkflowActivation {
+            timestamp: self.current_wf_time.map(Into::into),
+            is_replaying: self.replaying,
+            run_id: self.run_id.clone(),
+            history_length: self.last_processed_event as u32,
+            jobs,
+        }
+    }
+
+    pub(crate) fn has_pending_jobs(&self) -> bool {
+        !self.drive_me.peek_pending_jobs().is_empty()
+    }
+
+    pub(crate) fn has_pending_la_resolutions(&self) -> bool {
+        self.drive_me
+            .peek_pending_jobs()
+            .iter()
+            .any(|v| v.is_la_resolution)
+    }
+
+    /// Iterate the state machines, which consists of grabbing any pending outgoing commands from
+    /// the workflow code, handling them, and preparing them to be sent off to the server.
+    pub(crate) async fn iterate_machines(&mut self) -> Result<()> {
+        let results = self.drive_me.fetch_workflow_iteration_output().await;
+        self.handle_driven_results(results)?;
+        self.prepare_commands()?;
+        if self.workflow_is_finished() {
+            if let Some(rt) = self.total_runtime() {
+                self.metrics.wf_e2e_latency(rt);
+            }
+        }
+        Ok(())
+    }
+
+    /// Apply the next (unapplied) entire workflow task from history to these machines. Will replay
+    /// any events that need to be replayed until caught up to the newest WFT. May also fetch
+    /// history from server if needed.
+    pub(crate) async fn apply_next_wft_from_history(&mut self) -> Result<usize> {
+        // If we have already seen the terminal event for the entire workflow in a previous WFT,
+        // then we don't need to do anything here, and in fact we need to avoid re-applying the
+        // final WFT.
+        if self.have_seen_terminal_event {
+            return Ok(0);
+        }
+
+        let last_handled_wft_started_id = self.current_started_event_id;
+        let events = {
+            let mut evts = self
+                .last_history_from_server
+                .take_next_wft_sequence(last_handled_wft_started_id)
+                .await
+                .map_err(WFMachinesError::HistoryFetchingError)?;
+            // Do not re-process events we have already processed
+            evts.retain(|e| e.event_id > self.last_processed_event);
+            evts
+        };
+        let num_events_to_process = events.len();
+
+        // We're caught up on reply if there are no new events to process
+        if events.is_empty() {
+            self.replaying = false;
+        }
+        let replay_start = Instant::now();
+
+        if let Some(last_event) = events.last() {
+            if last_event.event_type == EventType::WorkflowTaskStarted as i32 {
+                self.next_started_event_id = last_event.event_id;
+            }
+        }
+
+        let mut history = events.into_iter().peekable();
+        while let Some(event) = history.next() {
+            if event.event_id != self.last_processed_event + 1 {
+                return Err(WFMachinesError::Fatal(format!(
+                    "History is out of order. Last processed event: {}, event id: {}",
+                    self.last_processed_event, event.event_id
+                )));
+            }
+            let next_event = history.peek();
+            let eid = event.event_id;
+            let etype = event.event_type();
+            self.handle_event(event, next_event.is_some())?;
+            self.last_processed_event = eid;
+            if etype == EventType::WorkflowTaskStarted && next_event.is_none() {
+                break;
+            }
+        }
+
+        // Scan through to the next WFT, searching for any patch / la markers, so that we can
+        // pre-resolve them.
+        for e in self.last_history_from_server.peek_next_wft_sequence() {
+            if let Some((patch_id, _)) = e.get_patch_marker_details() {
+                self.encountered_change_markers.insert(
+                    patch_id.clone(),
+                    ChangeInfo {
+                        created_command: false,
+                    },
+                );
+                // Found a patch marker
+                self.drive_me.send_job(
+                    workflow_activation_job::Variant::NotifyHasPatch(NotifyHasPatch { patch_id })
+                        .into(),
+                );
+            } else if e.is_local_activity_marker() {
+                self.local_activity_data.process_peekahead_marker(e)?;
+            }
+        }
+
+        if !self.replaying {
+            self.metrics.wf_task_replay_latency(replay_start.elapsed());
+        }
+
+        Ok(num_events_to_process)
+    }
+
     /// Handle a single event from the workflow history. `has_next_event` should be false if `event`
     /// is the last event in the history.
     ///
@@ -323,14 +467,8 @@ impl WorkflowMachines {
     /// event is applied to the machine, which may also return a nondeterminism error if the machine
     /// does not match the expected type. A fatal error may be returned if the machine is in an
     /// invalid state.
-    #[instrument(level = "debug", skip(self, event), fields(event=%event))]
+    #[instrument(skip(self, event), fields(event=%event))]
     fn handle_event(&mut self, event: HistoryEvent, has_next_event: bool) -> Result<()> {
-        if event.event_type() == EventType::Unspecified {
-            return Err(WFMachinesError::Fatal(format!(
-                "Event type is unspecified! This history is invalid. Event detail: {:?}",
-                event
-            )));
-        }
         if event.is_final_wf_execution_event() {
             self.have_seen_terminal_event = true;
         }
@@ -348,11 +486,6 @@ impl WorkflowMachines {
                 Ok(())
             };
         }
-
-        if event.is_command_event() {
-            self.handle_command_event(event)?;
-            return Ok(());
-        }
         if self.replaying
             && self.current_started_event_id
                 >= self.last_history_from_server.previous_started_event_id
@@ -361,59 +494,50 @@ impl WorkflowMachines {
             // Replay is finished
             self.replaying = false;
         }
+        if event.event_type() == EventType::Unspecified || event.attributes.is_none() {
+            return if !event.worker_may_ignore {
+                Err(WFMachinesError::Fatal(format!(
+                    "Event type is unspecified! This history is invalid. Event detail: {:?}",
+                    event
+                )))
+            } else {
+                debug!("Event is ignorable");
+                Ok(())
+            };
+        }
 
-        match event.get_initial_command_event_id() {
-            Some(initial_cmd_id) => {
-                // We remove the machine while we it handles events, then return it, to avoid
-                // borrowing from ourself mutably.
-                let maybe_machine = self.machines_by_event_id.remove(&initial_cmd_id);
-                match maybe_machine {
-                    Some(sm) => {
-                        self.submachine_handle_event(sm, event, has_next_event)?;
-                        // Restore machine if not in it's final state
-                        if !self.machine(sm).is_final_state() {
-                            self.machines_by_event_id.insert(initial_cmd_id, sm);
-                        }
+        if event.is_command_event() {
+            self.handle_command_event(event)?;
+            return Ok(());
+        }
+
+        if let Some(initial_cmd_id) = event.get_initial_command_event_id() {
+            // We remove the machine while we it handles events, then return it, to avoid
+            // borrowing from ourself mutably.
+            let maybe_machine = self.machines_by_event_id.remove(&initial_cmd_id);
+            match maybe_machine {
+                Some(sm) => {
+                    self.submachine_handle_event(sm, event, has_next_event)?;
+                    // Restore machine if not in it's final state
+                    if !self.machine(sm).is_final_state() {
+                        self.machines_by_event_id.insert(initial_cmd_id, sm);
                     }
-                    None => {
-                        return Err(WFMachinesError::Nondeterminism(format!(
-                            "During event handling, this event had an initial command ID but we \
+                }
+                None => {
+                    return Err(WFMachinesError::Nondeterminism(format!(
+                        "During event handling, this event had an initial command ID but we \
                             could not find a matching command for it: {:?}",
-                            event
-                        )));
-                    }
+                        event
+                    )));
                 }
             }
-            None => self.handle_non_stateful_event(event, has_next_event)?,
+        } else {
+            self.handle_non_stateful_event(event, has_next_event)?;
         }
 
         Ok(())
     }
 
-    /// Called when a workflow task started event has triggered. Ensures we are tracking the ID
-    /// of the current started event as well as workflow time properly.
-    fn task_started(&mut self, task_started_event_id: i64, time: SystemTime) -> Result<()> {
-        self.current_started_event_id = task_started_event_id;
-        self.wft_start_time = Some(time);
-        self.set_current_time(time);
-
-        // Notify local activity machines that we started a non-replay WFT, which will allow any
-        // which were waiting for a marker to instead decide to execute the LA since it clearly
-        // will not be resolved via marker.
-        if !self.replaying {
-            let mut resps = vec![];
-            for (k, mach) in self.all_machines.iter_mut() {
-                if let Machines::LocalActivityMachine(lam) = mach {
-                    resps.push((k, lam.encountered_non_replay_wft()?));
-                }
-            }
-            for (mkey, resp_set) in resps {
-                self.process_machine_responses(mkey, resp_set)?;
-            }
-        }
-        Ok(())
-    }
-
     /// A command event is an event which is generated from a command emitted as a result of
     /// performing a workflow task. Each command has a corresponding event. For example
     /// ScheduleActivityTaskCommand is recorded to the history as ActivityTaskScheduledEvent.
@@ -504,7 +628,7 @@ impl WorkflowMachines {
                     attrs,
                 )) = event.attributes
                 {
-                    if let Some(st) = event.event_time {
+                    if let Some(st) = event.event_time.clone() {
                         let as_systime: SystemTime = st.try_into()?;
                         self.workflow_start_time = Some(as_systime);
                         // Set the workflow time to be the event time of the first event, so that
@@ -516,6 +640,7 @@ impl WorkflowMachines {
                     self.drive_me.start(
                         self.workflow_id.clone(),
                         str_to_randomness_seed(&attrs.original_execution_run_id),
+                        event.event_time.unwrap_or_default(),
                         attrs,
                     );
                 } else {
@@ -536,7 +661,8 @@ impl WorkflowMachines {
                     attrs,
                 )) = event.attributes
                 {
-                    self.drive_me.signal(attrs.into());
+                    self.drive_me
+                        .send_job(workflow_activation::SignalWorkflow::from(attrs).into());
                 } else {
                     // err
                 }
@@ -548,7 +674,8 @@ impl WorkflowMachines {
                     ),
                 ) = event.attributes
                 {
-                    self.drive_me.cancel(attrs.into());
+                    self.drive_me
+                        .send_job(workflow_activation::CancelWorkflow::from(attrs).into());
                 } else {
                     // err
                 }
@@ -563,46 +690,6 @@ impl WorkflowMachines {
         Ok(())
     }
 
-    /// Fetches commands which are ready for processing from the state machines, generally to be
-    /// sent off to the server. They are not removed from the internal queue, that happens when
-    /// corresponding history events from the server are being handled.
-    pub(crate) fn get_commands(&self) -> Vec<ProtoCommand> {
-        self.commands
-            .iter()
-            .filter_map(|c| {
-                if !self.machine(c.machine).is_final_state() {
-                    match &c.command {
-                        MachineAssociatedCommand::Real(cmd) => Some((**cmd).clone()),
-                        MachineAssociatedCommand::FakeLocalActivityMarker(_) => None,
-                    }
-                } else {
-                    None
-                }
-            })
-            .collect()
-    }
-
-    /// Returns the next activation that needs to be performed by the lang sdk. Things like unblock
-    /// timer, etc. This does *not* cause any advancement of the state machines, it merely drains
-    /// from the outgoing queue of activation jobs.
-    ///
-    /// The job list may be empty, in which case it is expected the caller handles what to do in a
-    /// "no work" situation. Possibly, it may know about some work the machines don't, like queries.
-    pub(crate) fn get_wf_activation(&mut self) -> WorkflowActivation {
-        let jobs = self.drive_me.drain_jobs();
-        WorkflowActivation {
-            timestamp: self.current_wf_time.map(Into::into),
-            is_replaying: self.replaying,
-            run_id: self.run_id.clone(),
-            history_length: self.last_processed_event as u32,
-            jobs,
-        }
-    }
-
-    pub(crate) fn has_pending_jobs(&self) -> bool {
-        !self.drive_me.peek_pending_jobs().is_empty()
-    }
-
     fn set_current_time(&mut self, time: SystemTime) -> SystemTime {
         if self.current_wf_time.map_or(true, |t| t < time) {
             self.current_wf_time = Some(time);
@@ -611,102 +698,6 @@ impl WorkflowMachines {
             .expect("We have just ensured this is populated")
     }
 
-    /// Iterate the state machines, which consists of grabbing any pending outgoing commands from
-    /// the workflow code, handling them, and preparing them to be sent off to the server.
-    pub(crate) async fn iterate_machines(&mut self) -> Result<()> {
-        let results = self.drive_me.fetch_workflow_iteration_output().await;
-        self.handle_driven_results(results)?;
-        self.prepare_commands()?;
-        if self.workflow_is_finished() {
-            if let Some(rt) = self.total_runtime() {
-                self.metrics.wf_e2e_latency(rt);
-            }
-        }
-        Ok(())
-    }
-
-    /// Apply the next (unapplied) entire workflow task from history to these machines. Will replay
-    /// any events that need to be replayed until caught up to the newest WFT. May also fetch
-    /// history from server if needed.
-    pub(crate) async fn apply_next_wft_from_history(&mut self) -> Result<usize> {
-        // If we have already seen the terminal event for the entire workflow in a previous WFT,
-        // then we don't need to do anything here, and in fact we need to avoid re-applying the
-        // final WFT.
-        if self.have_seen_terminal_event {
-            return Ok(0);
-        }
-
-        let last_handled_wft_started_id = self.current_started_event_id;
-        let events = {
-            let mut evts = self
-                .last_history_from_server
-                .take_next_wft_sequence(last_handled_wft_started_id)
-                .await
-                .map_err(WFMachinesError::HistoryFetchingError)?;
-            // Do not re-process events we have already processed
-            evts.retain(|e| e.event_id > self.last_processed_event);
-            evts
-        };
-        let num_events_to_process = events.len();
-
-        // We're caught up on reply if there are no new events to process
-        // TODO: Probably this is unneeded if we evict whenever history is from non-sticky queue
-        if events.is_empty() {
-            self.replaying = false;
-        }
-        let replay_start = Instant::now();
-
-        if let Some(last_event) = events.last() {
-            if last_event.event_type == EventType::WorkflowTaskStarted as i32 {
-                self.next_started_event_id = last_event.event_id;
-            }
-        }
-
-        let mut history = events.into_iter().peekable();
-        while let Some(event) = history.next() {
-            if event.event_id != self.last_processed_event + 1 {
-                return Err(WFMachinesError::Fatal(format!(
-                    "History is out of order. Last processed event: {}, event id: {}",
-                    self.last_processed_event, event.event_id
-                )));
-            }
-            let next_event = history.peek();
-            let eid = event.event_id;
-            let etype = event.event_type;
-            self.handle_event(event, next_event.is_some())?;
-            self.last_processed_event = eid;
-            if etype == EventType::WorkflowTaskStarted as i32 && next_event.is_none() {
-                break;
-            }
-        }
-
-        // Scan through to the next WFT, searching for any patch markers, so that we can
-        // pre-resolve them.
-        for e in self.last_history_from_server.peek_next_wft_sequence() {
-            if let Some((patch_id, _)) = e.get_patch_marker_details() {
-                self.encountered_change_markers.insert(
-                    patch_id.clone(),
-                    ChangeInfo {
-                        created_command: false,
-                    },
-                );
-                // Found a patch marker
-                self.drive_me
-                    .send_job(workflow_activation_job::Variant::NotifyHasPatch(
-                        NotifyHasPatch { patch_id },
-                    ));
-            } else if e.is_local_activity_marker() {
-                self.local_activity_data.process_peekahead_marker(e)?;
-            }
-        }
-
-        if !self.replaying {
-            self.metrics.wf_task_replay_latency(replay_start.elapsed());
-        }
-
-        Ok(num_events_to_process)
-    }
-
     /// Wrapper for calling [TemporalStateMachine::handle_event] which appropriately takes action
     /// on the returned machine responses
     fn submachine_handle_event(
@@ -765,7 +756,7 @@ impl WorkflowMachines {
     ) -> Result<()> {
         let sm = self.machine(smk);
         if !machine_responses.is_empty() {
-            debug!(responses = %machine_responses.display(), machine_name = %sm.kind(),
+            debug!(responses = %machine_responses.display(), machine_name = %sm.name(),
                    "Machine produced responses");
         }
         self.process_machine_resps_impl(smk, machine_responses)
@@ -791,14 +782,12 @@ impl WorkflowMachines {
                     self.task_started(task_started_event_id, time)?;
                 }
                 MachineResponse::UpdateRunIdOnWorkflowReset { run_id: new_run_id } => {
-                    // TODO: Should this also update self.run_id? Should we track orig/current
-                    //   separately?
-                    self.drive_me
-                        .send_job(workflow_activation_job::Variant::UpdateRandomSeed(
-                            UpdateRandomSeed {
-                                randomness_seed: str_to_randomness_seed(&new_run_id),
-                            },
-                        ));
+                    self.drive_me.send_job(
+                        workflow_activation_job::Variant::UpdateRandomSeed(UpdateRandomSeed {
+                            randomness_seed: str_to_randomness_seed(&new_run_id),
+                        })
+                        .into(),
+                    );
                 }
                 MachineResponse::IssueNewCommand(c) => {
                     self.current_wf_task_commands.push_back(CommandAndMachine {
@@ -860,7 +849,7 @@ impl WorkflowMachines {
                                 Duration::from_secs(0),
                                 removed_act.attempt,
                                 None,
-                                None,
+                                removed_act.original_schedule_time,
                             )?;
                             self.process_machine_responses(smk, more_responses)?;
                         } else {
@@ -888,6 +877,30 @@ impl WorkflowMachines {
         Ok(())
     }
 
+    /// Called when a workflow task started event has triggered. Ensures we are tracking the ID
+    /// of the current started event as well as workflow time properly.
+    fn task_started(&mut self, task_started_event_id: i64, time: SystemTime) -> Result<()> {
+        self.current_started_event_id = task_started_event_id;
+        self.wft_start_time = Some(time);
+        self.set_current_time(time);
+
+        // Notify local activity machines that we started a non-replay WFT, which will allow any
+        // which were waiting for a marker to instead decide to execute the LA since it clearly
+        // will not be resolved via marker.
+        if !self.replaying {
+            let mut resps = vec![];
+            for (k, mach) in self.all_machines.iter_mut() {
+                if let Machines::LocalActivityMachine(lam) = mach {
+                    resps.push((k, lam.encountered_non_replay_wft()?));
+                }
+            }
+            for (mkey, resp_set) in resps {
+                self.process_machine_responses(mkey, resp_set)?;
+            }
+        }
+        Ok(())
+    }
+
     /// Handles results of the workflow activation, delegating work to the appropriate state
     /// machine. Returns a list of workflow jobs that should be queued in the pending activation for
     /// the next poll. This list will be populated only if state machine produced lang activations
@@ -1037,6 +1050,12 @@ impl WorkflowMachines {
                     // Nothing to do here, queries are handled above the machine level
                     unimplemented!("Query responses should not make it down into the machines")
                 }
+                WFCommand::ModifyWorkflowProperties(attrs) => {
+                    self.add_cmd_to_wf_task(
+                        modify_workflow_properties(attrs),
+                        CommandIdKind::NeverResolves,
+                    );
+                }
                 WFCommand::NoCommandsFromLang => (),
             }
         }
@@ -1143,10 +1162,7 @@ enum ChangeMarkerOutcome {
 
 /// Special handling for patch markers, when handling command events as in
 /// [WorkflowMachines::handle_command_event]
-fn change_marker_handling(
-    event: &HistoryEvent,
-    mach: &dyn TemporalStateMachine,
-) -> Result<ChangeMarkerOutcome> {
+fn change_marker_handling(event: &HistoryEvent, mach: &Machines) -> Result<ChangeMarkerOutcome> {
     if !mach.matches_event(event) {
         // Version markers can be skipped in the event they are deprecated
         if let Some((patch_name, deprecated)) = event.get_patch_marker_details() {
@@ -1162,11 +1178,11 @@ fn change_marker_handling(
                 patch_name
             )));
         }
-        // Version machines themselves may also not *have* matching markers, where non-deprecated
+        // Patch machines themselves may also not *have* matching markers, where non-deprecated
         // calls take the old path, and deprecated calls assume history is produced by a new-code
         // worker.
-        if mach.kind() == MachineKind::Patch {
-            debug!("Skipping non-matching event against version machine");
+        if matches!(mach, Machines::PatchMachine(_)) {
+            debug!("Skipping non-matching event against patch machine");
             return Ok(ChangeMarkerOutcome::SkipCommand);
         }
     }

data/bridge/sdk-core/core/src/worker/workflow/machines/workflow_task_state_machine.rs

@@ -1,8 +1,7 @@
 #![allow(clippy::enum_variant_names)]
 
 use super::{
-    workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, WFMachinesAdapter,
-    WFMachinesError,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, WFMachinesAdapter, WFMachinesError,
 };
 use rustfsm::{fsm, TransitionResult};
 use std::{
@@ -101,10 +100,6 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 | EventType::WorkflowTaskFailed
         )
     }
-
-    fn kind(&self) -> MachineKind {
-        MachineKind::WorkflowTask
-    }
 }
 
 impl TryFrom<HistoryEvent> for WorkflowTaskMachineEvents {

data/bridge/sdk-core/core/src/worker/workflow/managed_run/managed_wf_test.rs

@@ -87,7 +87,7 @@ impl ManagedWFFunc {
             "runid".to_string(),
             hist,
             Box::new(driver).into(),
-            Default::default(),
+            MetricsContext::no_op(),
         );
         let mgr = WorkflowManager::new_from_machines(state_machines);
         Self {
@@ -98,7 +98,7 @@ impl ManagedWFFunc {
         }
     }
 
-    #[instrument(level = "debug", skip(self))]
+    #[instrument(skip(self))]
     pub(crate) async fn get_next_activation(&mut self) -> Result<WorkflowActivation> {
         let res = self.mgr.get_next_activation().await?;
         debug!("Managed wf next activation: {}", &res);
@@ -116,7 +116,7 @@ impl ManagedWFFunc {
     }
 
     /// Feed new history, as if received a new poll result. Returns new activation
-    #[instrument(level = "debug", skip(self, update))]
+    #[instrument(skip(self, update))]
     pub(crate) async fn new_history(
         &mut self,
         update: HistoryUpdate,
@@ -174,7 +174,7 @@ impl ManagedWFFunc {
         self.future_handle.take().unwrap().await.unwrap()
     }
 
-    #[instrument(level = "debug", skip(self, res))]
+    #[instrument(skip(self, res))]
     async fn push_activation_to_wf(&mut self, res: &WorkflowActivation) -> Result<()> {
         if res.jobs.is_empty() {
             // Nothing to do here