@temporalio/core-bridge 0.16.0 → 0.17.1

package/Cargo.lock

@@ -1550,6 +1550,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-stream",
+ "tokio-util",
  "tonic 0.6.1",
  "tonic-build 0.6.0",
  "tower",

package/index.d.ts

@@ -125,6 +125,20 @@ export interface WorkerOptions {
    * Maximum number of Workflow instances to cache before automatic eviction
    */
   maxCachedWorkflows: number;
+  /**
+   * Longest interval for throttling activity heartbeats
+   * @default 60 seconds
+   */
+  maxHeartbeatThrottleIntervalMs: number;
+
+  /**
+   * Default interval for throttling activity heartbeats in case
+   * `ActivityOptions.heartbeat_timeout` is unset.
+   * When the timeout *is* set in the `ActivityOptions`, throttling is set to
+   * `heartbeat_timeout * 0.8`.
+   * @default 30 seconds
+   */
+  defaultHeartbeatThrottleIntervalMs: number;
 }
 
 /** Log level - must match rust log level names */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.node",
   "types": "index.d.ts",
@@ -19,7 +19,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.0.3",
-    "@temporalio/common": "^0.16.0",
+    "@temporalio/common": "^0.17.1",
     "arg": "^5.0.1",
     "cargo-cp-artifact": "^0.1.4",
     "which": "^2.0.2"
@@ -40,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "42638434f033db2b55c43c2a9a7751d883ba17ec"
+  "gitHead": "3ee26c92e9c18500f919654a402237a86e69652e"
 }

package/sdk-core/Cargo.toml

@@ -43,6 +43,7 @@ ringbuf = "0.2"
 slotmap = "1.0"
 thiserror = "1.0"
 tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio-util = { version = "0.6.9" }
 tokio-stream = "0.1"
 tonic = { version = "0.6", features = ["tls", "tls-roots"] }
 tower = "0.4"

package/sdk-core/fsm/rustfsm_procmacro/Cargo.toml

@@ -24,4 +24,4 @@ rustfsm_trait = { version = "0.1", path = "../rustfsm_trait" }
 trybuild = { version = "1.0", features = ["diff"] }
 
 [package.metadata.workspaces]
-independent = true
+independent = true

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use std::collections::{hash_map::Entry, HashMap, HashSet};
@@ -82,7 +80,7 @@ use syn::{
 ///                     ReadingCard { card_data: data.clone() }.into(),
 ///                     SharedState { last_id: Some(data) }
 ///                 )
-///             }   
+///             }
 ///         }
 ///     }
 /// }
@@ -200,7 +198,7 @@ impl Parse for StateMachineDefinition {
         // Parse visibility if present
         let visibility = input.parse()?;
         // parse the state machine name, command type, and error type
-        let (name, command_type, error_type, shared_state_type) = parse_machine_types(&input)
+        let (name, command_type, error_type, shared_state_type) = parse_machine_types(input)
             .map_err(|mut e| {
                 e.combine(Error::new(
                     e.span(),
@@ -235,7 +233,7 @@ impl Parse for StateMachineDefinition {
     }
 }
 
-fn parse_machine_types(input: &ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
+fn parse_machine_types(input: ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
     let _: kw::name = input.parse()?;
     let name: Ident = input.parse()?;
     input.parse::<Token![;]>()?;
@@ -443,7 +441,7 @@ impl StateMachineDefinition {
                                         },
                             multi_dests => {
                                 let string_dests: Vec<_> = multi_dests.iter()
-                                    .map(|i| i.to_string()).collect();
+                                    .map(ToString::to_string).collect();
                                 let enum_ident = Ident::new(&string_dests.join("Or"),
                                                             multi_dests[0].span());
                                 let multi_dest_enum = quote! {
@@ -558,6 +556,7 @@ impl StateMachineDefinition {
                 fn state(&self) -> &Self::State {
                     &self.state
                 }
+
                 fn set_state(&mut self, new: Self::State) {
                     self.state = new
                 }
@@ -590,7 +589,7 @@ impl StateMachineDefinition {
             #trait_impl
         };
 
-        output.into()
+        TokenStream::from(output)
     }
 
     fn all_states(&self) -> HashSet<Ident> {
@@ -628,7 +627,7 @@ impl StateMachineDefinition {
 /// Merge transition's dest state lists for those with the same from state & handler
 fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
     let mut map = HashMap::<_, Transition>::new();
-    transitions.into_iter().for_each(|t| {
+    for t in transitions {
         // We want to use the transition sans-destinations as the key
         let without_dests = {
             let mut wd = t.clone();
@@ -643,6 +642,6 @@ fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
                 v.insert(t);
             }
         }
-    });
+    }
     map.into_iter().map(|(_, v)| v).collect()
 }

package/sdk-core/fsm/rustfsm_trait/Cargo.toml

@@ -11,4 +11,4 @@ description = "Trait sub-crate of the `rustfsm` crate"
 [dependencies]
 
 [package.metadata.workspaces]
-independent = true
+independent = true

package/sdk-core/fsm/rustfsm_trait/src/lib.rs

@@ -112,7 +112,7 @@ where
     pub fn unwrap(self) -> Vec<M::Command> {
         match self {
             Self::Ok { commands } => commands,
-            _ => panic!("Transition was not successful!"),
+            Self::InvalidTransition => panic!("Transition was not successful!"),
         }
     }
 }

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -38,7 +38,7 @@ pub mod coresdk {
                 activity_id: String,
                 reason: ActivityCancelReason,
             ) -> Self {
-                ActivityTask {
+                Self {
                     task_token,
                     activity_id,
                     variant: Some(activity_task::Variant::Cancel(Cancel {
@@ -75,7 +75,7 @@ pub mod coresdk {
                     })),
                 }
             }
-            pub fn will_complete_async() -> Self {
+            pub const fn will_complete_async() -> Self {
                 Self {
                     status: Some(activity_result::Status::WillCompleteAsync(
                         WillCompleteAsync {},
@@ -195,7 +195,7 @@ pub mod coresdk {
                     "jobs: {})",
                     self.jobs
                         .iter()
-                        .map(|j| j.to_string())
+                        .map(ToString::to_string)
                         .collect::<Vec<_>>()
                         .as_slice()
                         .join(", ")
@@ -264,18 +264,25 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
-        use crate::coresdk::workflow_completion::wf_activation_completion::Status;
+        use crate::temporal::api::failure;
         tonic::include_proto!("coresdk.workflow_completion");
 
         impl wf_activation_completion::Status {
-            pub fn is_success(&self) -> bool {
+            pub const fn is_success(&self) -> bool {
                 match &self {
-                    Status::Successful(_) => true,
-                    Status::Failed(_) => false,
+                    Self::Successful(_) => true,
+                    Self::Failed(_) => false,
                 }
             }
         }
+
+        impl From<failure::v1::Failure> for Failure {
+            fn from(f: failure::v1::Failure) -> Self {
+                Failure { failure: Some(f) }
+            }
+        }
     }
+
     pub mod child_workflow {
         tonic::include_proto!("coresdk.child_workflow");
     }
@@ -370,7 +377,7 @@ pub mod coresdk {
 
     impl From<wf_activation_job::Variant> for WfActivationJob {
         fn from(a: wf_activation_job::Variant) -> Self {
-            WfActivationJob { variant: Some(a) }
+            Self { variant: Some(a) }
         }
     }
 
@@ -382,7 +389,7 @@ pub mod coresdk {
 
     impl From<workflow_command::Variant> for WorkflowCommand {
         fn from(v: workflow_command::Variant) -> Self {
-            WorkflowCommand { variant: Some(v) }
+            Self { variant: Some(v) }
         }
     }
 
@@ -591,7 +598,7 @@ pub mod coresdk {
     }
 
     impl ActivityResult {
-        pub fn ok(result: Payload) -> Self {
+        pub const fn ok(result: Payload) -> Self {
             Self {
                 status: Some(activity_result::activity_result::Status::Completed(
                     activity_result::Success {
@@ -615,24 +622,18 @@ pub mod coresdk {
                 .workflow_execution
                 .map(|we| (we.workflow_id, we.run_id))
                 .unwrap_or_default();
-            ActivityTask {
+            Self {
                 task_token: r.task_token,
                 activity_id: r.activity_id,
                 variant: Some(activity_task::activity_task::Variant::Start(
                     activity_task::Start {
                         workflow_namespace: r.workflow_namespace,
-                        workflow_type: r
-                            .workflow_type
-                            .map(|wt| wt.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        workflow_type: r.workflow_type.map_or_else(|| "".to_string(), |wt| wt.name),
                         workflow_execution: Some(common::WorkflowExecution {
                             workflow_id,
                             run_id,
                         }),
-                        activity_type: r
-                            .activity_type
-                            .map(|at| at.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        activity_type: r.activity_type.map_or_else(|| "".to_string(), |at| at.name),
                         header_fields: r.header.map(Into::into).unwrap_or_default(),
                         input: Vec::from_payloads(r.input),
                         heartbeat_details: Vec::from_payloads(r.heartbeat_details),
@@ -664,7 +665,7 @@ pub mod coresdk {
 
     impl From<common::WorkflowExecution> for WorkflowExecution {
         fn from(exc: common::WorkflowExecution) -> Self {
-            WorkflowExecution {
+            Self {
                 workflow_id: exc.workflow_id,
                 run_id: exc.run_id,
             }
@@ -767,7 +768,7 @@ pub mod coresdk {
         T: AsRef<[u8]>,
     {
         fn from(v: T) -> Self {
-            Payloads {
+            Self {
                 payloads: vec![v.into()],
             }
         }
@@ -786,10 +787,10 @@ pub mod coresdk {
             match v.payloads.pop() {
                 None => Err(PayloadsToPayloadError::NoPayload),
                 Some(p) => {
-                    if !v.payloads.is_empty() {
-                        Err(PayloadsToPayloadError::MoreThanOnePayload)
-                    } else {
+                    if v.payloads.is_empty() {
                         Ok(p.into())
+                    } else {
+                        Err(PayloadsToPayloadError::MoreThanOnePayload)
                     }
                 }
             }
@@ -1091,26 +1092,22 @@ pub mod temporal {
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
-                        if let Some(et) = EventType::from_i32(self.event_type) {
-                            match et {
-                                EventType::ActivityTaskScheduled
-                                | EventType::ActivityTaskCancelRequested
-                                | EventType::MarkerRecorded
-                                | EventType::RequestCancelExternalWorkflowExecutionInitiated
-                                | EventType::SignalExternalWorkflowExecutionInitiated
-                                | EventType::StartChildWorkflowExecutionInitiated
-                                | EventType::TimerCanceled
-                                | EventType::TimerStarted
-                                | EventType::UpsertWorkflowSearchAttributes
-                                | EventType::WorkflowExecutionCanceled
-                                | EventType::WorkflowExecutionCompleted
-                                | EventType::WorkflowExecutionContinuedAsNew
-                                | EventType::WorkflowExecutionFailed => true,
-                                _ => false,
-                            }
-                        } else {
-                            false
-                        }
+                        EventType::from_i32(self.event_type).map_or(false, |et| match et {
+                            EventType::ActivityTaskScheduled
+                            | EventType::ActivityTaskCancelRequested
+                            | EventType::MarkerRecorded
+                            | EventType::RequestCancelExternalWorkflowExecutionInitiated
+                            | EventType::SignalExternalWorkflowExecutionInitiated
+                            | EventType::StartChildWorkflowExecutionInitiated
+                            | EventType::TimerCanceled
+                            | EventType::TimerStarted
+                            | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowExecutionCanceled
+                            | EventType::WorkflowExecutionCompleted
+                            | EventType::WorkflowExecutionContinuedAsNew
+                            | EventType::WorkflowExecutionFailed => true,
+                            _ => false,
+                        })
                     }
 
                     /// Returns the command's initiating event id, if present. This is the id of the
@@ -1262,16 +1259,14 @@ pub mod temporal {
                         let last_event = self
                             .history
                             .as_ref()
-                            .map(|h| h.events.last().map(|he| he.event_id))
-                            .flatten()
+                            .and_then(|h| h.events.last().map(|he| he.event_id))
                             .unwrap_or(0);
                         write!(
                             f,
                             "PollWFTQResp(run_id: {}, attempt: {}, last_event: {})",
                             self.workflow_execution
                                 .as_ref()
-                                .map(|we| we.run_id.as_str())
-                                .unwrap_or(""),
+                                .map_or("", |we| we.run_id.as_str()),
                             self.attempt,
                             last_event
                         )

package/sdk-core/src/core_tests/activity_tasks.rs

@@ -76,7 +76,7 @@ async fn max_activities_respected() {
     core.register_worker(
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
-            .max_outstanding_activities(2usize)
+            .max_outstanding_activities(2_usize)
             .build()
             .unwrap(),
     )
@@ -163,7 +163,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token.clone(),
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     // We have to wait a beat for the heartbeat to be processed
     sleep(Duration::from_millis(10)).await;
@@ -183,7 +183,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token,
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     sleep(Duration::from_millis(10)).await;
     // Since cancels always come before new tasks, if we get a new non-cancel task, we did not
@@ -251,7 +251,7 @@ async fn activity_cancel_interrupts_poll() {
             core.record_activity_heartbeat(ActivityHeartbeat {
                 task_token: act.task_token,
                 task_queue: TEST_Q.to_string(),
-                details: vec![vec![1u8, 2, 3].into()],
+                details: vec![vec![1_u8, 2, 3].into()],
             });
             last_finisher.store(1, Ordering::SeqCst);
         },
@@ -358,7 +358,7 @@ async fn many_concurrent_heartbeat_cancels() {
             .task_queue(TEST_Q)
             .max_outstanding_activities(CONCURRENCY_NUM)
             // Only 1 poll at a time to avoid over-polling and running out of responses
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )

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

@@ -91,8 +91,8 @@ async fn shutdown_interrupts_both_polls() {
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
             // Need only 1 concurrent pollers for mock expectations to work here
-            .max_concurrent_wft_polls(1usize)
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_wft_polls(1_usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )

package/sdk-core/src/core_tests/queries.rs

@@ -290,10 +290,17 @@ async fn legacy_query_failure_on_wft_failure() {
     core.shutdown().await;
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn legacy_query_with_full_history_after_complete() {
+async fn legacy_query_after_complete(#[values(false, true)] full_history: bool) {
     let wfid = "fake_wf_id";
-    let t = canned_histories::single_timer_wf_completes("1");
+    let t = if full_history {
+        canned_histories::single_timer_wf_completes("1")
+    } else {
+        let mut t = canned_histories::single_timer("1");
+        t.add_workflow_task_completed();
+        t
+    };
     let query_with_hist_task = {
         let mut pr = hist_to_poll_resp(
             &t,

package/sdk-core/src/core_tests/workflow_tasks.rs

@@ -642,9 +642,9 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                                 UpdateRandomSeed{randomness_seed})),
                         }] => {
                             assert_ne!(randomness_seed_from_start.load(Ordering::SeqCst),
-                                      *randomness_seed)
+                                      *randomness_seed);
                         }
-                    )
+                    );
                 },
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),
@@ -1619,19 +1619,19 @@ async fn failing_wft_doesnt_eat_permit_forever() {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_workflow_task_scheduled_and_started();
 
-    let failures = 5;
-    // One extra response for when we stop failing
-    let resps = (1..=(failures + 1)).map(|_| 1);
     let mock = MockServerGatewayApis::new();
-    let mut mock = single_hist_mock_sg("fake_wf_id", t, resps, mock, true);
+    let mut mock = single_hist_mock_sg("fake_wf_id", t, [1, 1, 1], mock, true);
     mock.worker_cfg(TEST_Q, |cfg| {
         cfg.max_cached_workflows = 2;
         cfg.max_outstanding_workflow_tasks = 2;
     });
+    let outstanding_mock_tasks = mock.outstanding_task_map.clone();
     let core = mock_core(mock);
 
-    // Spin failing the WFT to verify that we don't get stuck
-    for _ in 1..=failures {
+    let mut run_id = "".to_string();
+    // Fail twice, verifying a permit is eaten. We cannot fail the same run more than twice in a row
+    // because we purposefully time out rather than spamming.
+    for _ in 1..=2 {
         let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
         // Issue a nonsense completion that will trigger a WFT failure
         core.complete_workflow_activation(WfActivationCompletion::from_cmd(
@@ -1648,11 +1648,90 @@ async fn failing_wft_doesnt_eat_permit_forever() {
                 variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
             },]
         );
+        run_id = activation.run_id.clone();
+        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
+            .await
+            .unwrap();
+        assert_eq!(core.outstanding_wfts(TEST_Q), 0);
+        assert_eq!(core.available_wft_permits(TEST_Q), 2);
+    }
+    // We should be "out of work" because the mock service thinks we didn't complete the last task,
+    // which we didn't, because we don't spam failures. The real server would eventually time out
+    // the task. Mock doesn't understand that, so the WFT permit is released because eventually a
+    // new one will be generated. We manually clear the mock's outstanding task list so the next
+    // poll will work.
+    outstanding_mock_tasks
+        .unwrap()
+        .write()
+        .remove_by_left(&run_id);
+    let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
+    core.complete_workflow_activation(WfActivationCompletion::from_cmd(
+        TEST_Q,
+        activation.run_id,
+        CompleteWorkflowExecution { result: None }.into(),
+    ))
+    .await
+    .unwrap();
+
+    core.shutdown().await;
+}
+
+#[tokio::test]
+async fn cache_miss_doesnt_eat_permit_forever() {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_we_signaled("sig", vec![]);
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let mut mh = MockPollCfg::from_resp_batches(
+        "fake_wf_id",
+        t,
+        [
+            ResponseType::ToTaskNum(1),
+            ResponseType::OneTask(2),
+            ResponseType::ToTaskNum(1),
+            ResponseType::OneTask(2),
+            ResponseType::ToTaskNum(1),
+            ResponseType::OneTask(2),
+            // Last one to complete successfully
+            ResponseType::ToTaskNum(1),
+        ],
+        MockServerGatewayApis::new(),
+    );
+    mh.num_expected_fails = Some(3);
+    mh.expect_fail_wft_matcher =
+        Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::ResetStickyTaskQueue));
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(TEST_Q, |cfg| {
+        cfg.max_outstanding_workflow_tasks = 2;
+    });
+    let core = mock_core(mock);
+
+    // Spin missing the cache to verify that we don't get stuck
+    for _ in 1..=3 {
+        // Start
+        let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
+        core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
+            .await
+            .unwrap();
+        // Evict
+        let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
+        assert_matches!(
+            activation.jobs.as_slice(),
+            [WfActivationJob {
+                variant: Some(wf_activation_job::Variant::RemoveFromCache(_)),
+            },]
+        );
         core.complete_workflow_activation(WfActivationCompletion::empty(TEST_Q, activation.run_id))
             .await
             .unwrap();
         assert_eq!(core.outstanding_wfts(TEST_Q), 0);
         assert_eq!(core.available_wft_permits(TEST_Q), 2);
+        // When we loop back up, the poll will trigger a cache miss, which we should immediately
+        // reply to WFT with failure, and then poll again, which will deliver the from-the-start
+        // history
     }
     let activation = core.poll_workflow_activation(TEST_Q).await.unwrap();
     core.complete_workflow_activation(WfActivationCompletion::from_cmd(

package/sdk-core/src/errors.rs

@@ -1,6 +1,6 @@
 //! Error types exposed by public APIs
 
-use crate::{machines::WFMachinesError, task_token::TaskToken, WorkerLookupErr};
+use crate::{machines::WFMachinesError, WorkerLookupErr};
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityResult, workflow_completion::WfActivationCompletion,
 };
@@ -11,17 +11,15 @@ pub(crate) struct WorkflowUpdateError {
     /// Underlying workflow error
     pub source: WFMachinesError,
     /// The run id of the erring workflow
+    #[allow(dead_code)] // Useful in debug output
     pub run_id: String,
-    /// The task token associated with this update, if one existed yet.
-    pub task_token: Option<TaskToken>,
 }
 
 impl From<WorkflowMissingError> for WorkflowUpdateError {
     fn from(wme: WorkflowMissingError) -> Self {
-        WorkflowUpdateError {
+        Self {
             source: WFMachinesError::Fatal("Workflow machines missing".to_string()),
             run_id: wme.run_id,
-            task_token: None,
         }
     }
 }
@@ -72,8 +70,8 @@ pub enum PollWfError {
 impl From<WorkerLookupErr> for PollWfError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(_) => PollWfError::ShutDown,
-            WorkerLookupErr::NoWorker(s) => PollWfError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
+            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
         }
     }
 }
@@ -97,8 +95,8 @@ pub enum PollActivityError {
 impl From<WorkerLookupErr> for PollActivityError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(_) => PollActivityError::ShutDown,
-            WorkerLookupErr::NoWorker(s) => PollActivityError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
+            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
         }
     }
 }
@@ -127,8 +125,9 @@ pub enum CompleteWfError {
 impl From<WorkerLookupErr> for CompleteWfError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(s) => CompleteWfError::NoWorkerForQueue(s),
-            WorkerLookupErr::NoWorker(s) => CompleteWfError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
+                Self::NoWorkerForQueue(s)
+            }
         }
     }
 }
@@ -156,8 +155,9 @@ pub enum CompleteActivityError {
 impl From<WorkerLookupErr> for CompleteActivityError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(s) => CompleteActivityError::NoWorkerForQueue(s),
-            WorkerLookupErr::NoWorker(s) => CompleteActivityError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
+                Self::NoWorkerForQueue(s)
+            }
         }
     }
 }