@temporalio/core-bridge 1.7.4 → 1.8.1

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

@@ -21,7 +21,8 @@ use std::{
 };
 use temporal_client::WorkflowOptions;
 use temporal_sdk::{
-    ActContext, ActivityCancelledError, LocalActivityOptions, WfContext, WorkflowResult,
+    ActContext, ActivityCancelledError, LocalActivityOptions, WfContext, WorkflowFunction,
+    WorkflowResult,
 };
 use temporal_sdk_core_api::{
     errors::{PollActivityError, PollWfError},
@@ -48,7 +49,7 @@ use temporal_sdk_core_protos::{
 use temporal_sdk_core_test_utils::{
     schedule_local_activity_cmd, start_timer_cmd, WorkerTestHelpers,
 };
-use tokio::{join, sync::Barrier};
+use tokio::{join, select, sync::Barrier};
 
 async fn echo(_ctx: ActContext, e: String) -> anyhow::Result<String> {
     Ok(e)
@@ -883,6 +884,96 @@ async fn test_schedule_to_start_timeout_not_based_on_original_time(
     worker.run_until_done().await.unwrap();
 }
 
+#[rstest::rstest]
+#[tokio::test]
+async fn start_to_close_timeout_allows_retries(#[values(true, false)] la_completes: bool) {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    if la_completes {
+        t.add_local_activity_marker(1, "1", Some("hi".into()), None, |_| {});
+    } else {
+        t.add_local_activity_marker(
+            1,
+            "1",
+            None,
+            Some(Failure::application_failure("la failed".to_string(), false)),
+            |_| {},
+        );
+    }
+    t.add_full_wf_task();
+    t.add_workflow_execution_completed();
+
+    let wf_id = "fakeid";
+    let mock = mock_workflow_client();
+    let mh = MockPollCfg::from_resp_batches(
+        wf_id,
+        t,
+        [ResponseType::ToTaskNum(1), ResponseType::AllHistory],
+        mock,
+    );
+    let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
+
+    worker.register_wf(
+        DEFAULT_WORKFLOW_TYPE.to_owned(),
+        move |ctx: WfContext| async move {
+            let la_res = ctx
+                .local_activity(LocalActivityOptions {
+                    activity_type: DEFAULT_ACTIVITY_TYPE.to_string(),
+                    input: "hi".as_json_payload().expect("serializes fine"),
+                    retry_policy: RetryPolicy {
+                        initial_interval: Some(prost_dur!(from_millis(20))),
+                        backoff_coefficient: 1.0,
+                        maximum_interval: None,
+                        maximum_attempts: 5,
+                        non_retryable_error_types: vec![],
+                    },
+                    start_to_close_timeout: Some(prost_dur!(from_millis(25))),
+                    ..Default::default()
+                })
+                .await;
+            if la_completes {
+                assert!(la_res.completed_ok());
+            } else {
+                assert_eq!(la_res.timed_out(), Some(TimeoutType::StartToClose));
+            }
+            Ok(().into())
+        },
+    );
+    let attempts: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
+    let cancels: &'static _ = Box::leak(Box::new(AtomicUsize::new(0)));
+    worker.register_activity(
+        DEFAULT_ACTIVITY_TYPE,
+        move |ctx: ActContext, _: String| async move {
+            // Timeout the first 4 attempts, or all of them if we intend to fail
+            if attempts.fetch_add(1, Ordering::AcqRel) < 4 || !la_completes {
+                select! {
+                    _ = tokio::time::sleep(Duration::from_millis(100)) => (),
+                    _ = ctx.cancelled() => {
+                        cancels.fetch_add(1, Ordering::AcqRel);
+                        return Err(anyhow!(ActivityCancelledError::default()));
+                    }
+                }
+            }
+            Ok(())
+        },
+    );
+    worker
+        .submit_wf(
+            wf_id.to_owned(),
+            DEFAULT_WORKFLOW_TYPE.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    // Activity should have been attempted all 5 times
+    assert_eq!(attempts.load(Ordering::Acquire), 5);
+    let num_cancels = if la_completes { 4 } else { 5 };
+    assert_eq!(cancels.load(Ordering::Acquire), num_cancels);
+}
+
 #[tokio::test]
 async fn wft_failure_cancels_running_las() {
     let mut t = TestHistoryBuilder::default();
@@ -964,17 +1055,18 @@ async fn resolved_las_not_recorded_if_wft_fails_many_times() {
     mh.num_expected_completions = Some(0.into());
     let mut worker = mock_sdk_cfg(mh, |w| w.max_cached_workflows = 1);
 
+    #[allow(unreachable_code)]
     worker.register_wf(
         DEFAULT_WORKFLOW_TYPE.to_owned(),
-        |ctx: WfContext| async move {
+        WorkflowFunction::new::<_, _, ()>(|ctx: WfContext| async move {
             ctx.local_activity(LocalActivityOptions {
                 activity_type: "echo".to_string(),
                 input: "hi".as_json_payload().expect("serializes fine"),
                 ..Default::default()
             })
             .await;
-            panic!("Oh nooooo")
-        },
+            panic!()
+        }),
     );
     worker.register_activity(
         "echo",

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

@@ -64,7 +64,7 @@ async fn shutdown_interrupts_both_polls() {
     mock_client
         .expect_poll_workflow_task()
         .times(1)
-        .returning(move |_, _| {
+        .returning(move |_| {
             async move {
                 BARR.wait().await;
                 sleep(Duration::from_secs(1)).await;

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

@@ -1,13 +1,13 @@
 use crate::{
     prost_dur,
     test_help::{
-        build_fake_worker, build_mock_pollers, canned_histories, mock_manual_poller, mock_worker,
-        MockPollCfg, MockWorkerInputs, MocksHolder, ResponseType, WorkerExt,
+        build_fake_worker, build_mock_pollers, canned_histories, mock_worker, MockPollCfg,
+        MockWorkerInputs, MocksHolder, ResponseType, WorkerExt,
     },
     worker::client::mocks::mock_workflow_client,
     PollActivityError, PollWfError,
 };
-use futures::FutureExt;
+use futures_util::{stream, stream::StreamExt};
 use std::{cell::RefCell, time::Duration};
 use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::{
@@ -16,7 +16,9 @@ use temporal_sdk_core_protos::{
         workflow_commands::{workflow_command, CompleteWorkflowExecution, StartTimer},
         workflow_completion::WorkflowActivationCompletion,
     },
-    temporal::api::workflowservice::v1::RespondWorkflowTaskCompletedResponse,
+    temporal::api::workflowservice::v1::{
+        PollWorkflowTaskQueueResponse, RespondWorkflowTaskCompletedResponse,
+    },
 };
 use temporal_sdk_core_test_utils::start_timer_cmd;
 use tokio::sync::{watch, Barrier};
@@ -87,20 +89,18 @@ async fn shutdown_worker_can_complete_pending_activation() {
 #[tokio::test]
 async fn worker_shutdown_during_poll_doesnt_deadlock() {
     let (tx, rx) = watch::channel(false);
-    let mut mock_poller = mock_manual_poller();
     let rx = rx.clone();
-    mock_poller.expect_poll().returning(move || {
-        let mut rx = rx.clone();
-        async move {
-            // Don't resolve polls until worker shuts down
-            rx.changed().await.unwrap();
-            // We don't want to return a real response here because it would get buffered and
-            // then we'd have real work to do to be able to finish shutdown.
-            Some(Ok(Default::default()))
-        }
-        .boxed()
+    let stream = stream::unfold(rx, |mut rx| async move {
+        // Don't resolve polls until worker shuts down
+        rx.changed().await.unwrap();
+        // We don't want to return a real response here because it would get buffered and
+        // then we'd have real work to do to be able to finish shutdown.
+        Some((
+            Ok(PollWorkflowTaskQueueResponse::default().try_into().unwrap()),
+            rx,
+        ))
     });
-    let mw = MockWorkerInputs::new_from_poller(Box::new(mock_poller));
+    let mw = MockWorkerInputs::new(stream.boxed());
     let mut mock_client = mock_workflow_client();
     mock_client
         .expect_complete_workflow_task()

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

@@ -7,7 +7,7 @@ use crate::{
         build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories,
         gen_assert_and_fail, gen_assert_and_reply, hist_to_poll_resp, mock_sdk, mock_sdk_cfg,
         mock_worker, poll_and_reply, poll_and_reply_clears_outstanding_evicts, single_hist_mock_sg,
-        test_worker_cfg, FakeWfResponses, MockPollCfg, MocksHolder, ResponseType,
+        test_worker_cfg, FakeWfResponses, MockPollCfg, MocksHolder, ResponseType, WorkerExt,
         WorkflowCachingPolicy::{self, AfterEveryReply, NonSticky},
     },
     worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
@@ -18,7 +18,8 @@ use rstest::{fixture, rstest};
 use std::{
     collections::{HashMap, HashSet, VecDeque},
     sync::{
-        atomic::{AtomicU64, Ordering},
+        atomic::{AtomicU64, AtomicUsize, Ordering},
+        mpsc::sync_channel,
         Arc,
     },
     time::Duration,
@@ -29,6 +30,7 @@ use temporal_sdk_core_api::{errors::PollWfError, Worker as WorkerTrait};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::{self as ar, activity_resolution, ActivityResolution},
+        common::VersioningIntent,
         workflow_activation::{
             remove_from_cache::EvictionReason, workflow_activation_job, FireTimer, ResolveActivity,
             StartWorkflow, UpdateRandomSeed, WorkflowActivationJob,
@@ -36,7 +38,7 @@ use temporal_sdk_core_protos::{
         workflow_commands::{
             ActivityCancellationType, CancelTimer, CompleteWorkflowExecution,
             ContinueAsNewWorkflowExecution, FailWorkflowExecution, RequestCancelActivity,
-            ScheduleActivity, SetPatchMarker,
+            ScheduleActivity, SetPatchMarker, StartChildWorkflowExecution,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
@@ -60,6 +62,7 @@ use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, WorkerTestHelp
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
+    time,
 };
 
 #[fixture(hist_batches = &[])]
@@ -1535,8 +1538,6 @@ async fn failing_wft_doesnt_eat_permit_forever() {
             .unwrap();
     }
     assert_eq!(worker.outstanding_workflow_tasks().await, 0);
-    // 1 permit is in use because the next task is buffered and has re-used the permit
-    assert_eq!(worker.available_wft_permits().await, 1);
     // 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
@@ -1545,7 +1546,7 @@ async fn failing_wft_doesnt_eat_permit_forever() {
     outstanding_mock_tasks.unwrap().release_run(&run_id);
     let activation = worker.poll_workflow_activation().await.unwrap();
     // There should be no change in permits, since this just unbuffered the buffered task
-    assert_eq!(worker.available_wft_permits().await, 1);
+    assert_eq!(worker.available_wft_permits(), 1);
     worker
         .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             activation.run_id,
@@ -1554,7 +1555,7 @@ async fn failing_wft_doesnt_eat_permit_forever() {
         .await
         .unwrap();
     worker.shutdown().await;
-    assert_eq!(worker.available_wft_permits().await, 2);
+    assert_eq!(worker.available_wft_permits(), 2);
 }
 
 #[tokio::test]
@@ -1647,6 +1648,45 @@ async fn cache_miss_will_fetch_history() {
     worker.shutdown().await;
 }
 
+#[tokio::test]
+async fn history_byte_size_and_can_suggestion_in_activation() {
+    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();
+    t.modify_event(7, |he| {
+        if let Some(history_event::Attributes::WorkflowTaskStartedEventAttributes(ref mut attrs)) =
+            he.attributes
+        {
+            attrs.suggest_continue_as_new = true;
+        }
+    });
+
+    let mh = MockPollCfg::from_resp_batches(
+        "fake_wf_id",
+        t,
+        [ResponseType::ToTaskNum(1), ResponseType::OneTask(2)],
+        mock_workflow_client(),
+    );
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(|cfg| cfg.max_cached_workflows = 1);
+    let worker = mock_worker(mock);
+
+    let activation = worker.poll_workflow_activation().await.unwrap();
+    // Test builder always does num events * 10
+    assert_eq!(activation.history_size_bytes, 30);
+    assert!(!activation.continue_as_new_suggested);
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(activation.run_id))
+        .await
+        .unwrap();
+    let activation = worker.poll_workflow_activation().await.unwrap();
+    assert_eq!(activation.history_size_bytes, 70);
+    assert!(activation.continue_as_new_suggested);
+}
+
 /// This test verifies that WFTs which come as replies to completing a WFT are properly delivered
 /// via activation polling.
 #[tokio::test]
@@ -1875,7 +1915,7 @@ async fn poll_faster_than_complete_wont_overflow_cache() {
 
     join!(blocking_poll, complete_evict);
     // p5 outstanding and final poll outstanding -- hence one permit available
-    assert_eq!(core.available_wft_permits().await, 1);
+    assert_eq!(core.available_wft_permits(), 1);
     assert_eq!(core.cached_workflows().await, 3);
 }
 
@@ -2002,25 +2042,23 @@ async fn no_race_acquiring_permits() {
     // We need to allow two polls to happen by triggering two processing events in the workflow
     // stream, but then delivering the actual tasks after that
     let task_barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));
-    mock_client
-        .expect_poll_workflow_task()
-        .returning(move |_, _| {
-            let t = canned_histories::single_timer("1");
-            let poll_resp = hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp;
-            async move {
-                task_barr.wait().await;
-                Ok(poll_resp.clone())
-            }
-            .boxed()
-        });
+    mock_client.expect_poll_workflow_task().returning(move |_| {
+        let t = canned_histories::single_timer("1");
+        let poll_resp = hist_to_poll_resp(&t, wfid.to_owned(), 2.into()).resp;
+        async move {
+            task_barr.wait().await;
+            Ok(poll_resp.clone())
+        }
+        .boxed()
+    });
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| async move { Ok(Default::default()) }.boxed());
 
     let worker = Worker::new_test(
         test_worker_cfg()
-            .max_outstanding_workflow_tasks(1_usize)
-            .max_cached_workflows(10_usize)
+            .max_outstanding_workflow_tasks(2_usize)
+            .max_cached_workflows(0_usize)
             .build()
             .unwrap(),
         mock_client,
@@ -2057,6 +2095,7 @@ async fn no_race_acquiring_permits() {
         task_barr.wait().await;
     };
     join!(poll_1_f, poll_2_f, other_f);
+    worker.drain_pollers_and_shutdown().await;
 }
 
 #[tokio::test]
@@ -2079,16 +2118,14 @@ async fn continue_as_new_preserves_some_values() {
         t.add_full_wf_task();
         t
     };
-    mock_client
-        .expect_poll_workflow_task()
-        .returning(move |_, _| {
-            Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
-        });
+    mock_client.expect_poll_workflow_task().returning(move |_| {
+        Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
+    });
     mock_client
         .expect_complete_workflow_task()
         .returning(move |mut c| {
-            let can_cmd = c.commands.pop().unwrap().attributes.unwrap();
-            if let Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(a) = can_cmd {
+            let cmd = c.commands.pop().unwrap().attributes.unwrap();
+            if let Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(a) = cmd {
                 assert_eq!(a.workflow_type.unwrap().name, "meow");
                 assert_eq!(a.memo, wes_attrs.memo);
                 assert_eq!(a.search_attributes, wes_attrs.search_attributes);
@@ -2588,3 +2625,185 @@ async fn history_length_with_fail_and_timeout(
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn poller_wont_run_ahead_of_task_slots() {
+    let popped_tasks = Arc::new(AtomicUsize::new(0));
+    let ptc = popped_tasks.clone();
+    let mut bunch_of_first_tasks = (1..50).map(move |i| {
+        ptc.fetch_add(1, Ordering::Relaxed);
+        hist_to_poll_resp(
+            &canned_histories::single_timer(&format!("{i}")),
+            format!("wf-{i}"),
+            1.into(),
+        )
+        .resp
+    });
+    let mut mock_client = mock_workflow_client();
+    mock_client
+        .expect_poll_workflow_task()
+        .returning(move |_| Ok(bunch_of_first_tasks.next().unwrap()));
+    mock_client
+        .expect_complete_workflow_task()
+        .returning(|_| Ok(Default::default()));
+
+    let worker = Worker::new_test(
+        test_worker_cfg()
+            .max_cached_workflows(10_usize)
+            .max_outstanding_workflow_tasks(10_usize)
+            .max_concurrent_wft_polls(10_usize)
+            .no_remote_activities(true)
+            .build()
+            .unwrap(),
+        mock_client,
+    );
+
+    // Should be able to get up to 10 tasks
+    let mut tasks = vec![];
+    for _ in 0..10 {
+        tasks.push(worker.poll_workflow_activation().await.unwrap());
+    }
+
+    assert_eq!(worker.outstanding_workflow_tasks().await, 10);
+    assert_eq!(worker.available_wft_permits(), 0);
+    assert_eq!(worker.unused_wft_permits(), 0);
+
+    // This one should hang until we complete some tasks since we're at the limit
+    let hung_poll = async {
+        // This should end up getting shut down after the other routine finishes tasks
+        assert_matches!(
+            worker.poll_workflow_activation().await.unwrap_err(),
+            PollWfError::ShutDown
+        );
+    };
+    // Wait for a bit concurrently with above, verify no extra tasks got taken, shutdown
+    let ender = async {
+        time::sleep(Duration::from_millis(300)).await;
+        // initiate shutdown, then complete open tasks
+        worker.initiate_shutdown();
+        for t in tasks {
+            worker
+                .complete_workflow_activation(WorkflowActivationCompletion::empty(t.run_id))
+                .await
+                .unwrap();
+        }
+        worker.shutdown().await;
+    };
+    join!(hung_poll, ender);
+    // We shouldn't have got more than the 10 tasks from the poller -- verifying that the concurrent
+    // polling is not exceeding the task limit
+    assert_eq!(popped_tasks.load(Ordering::Relaxed), 10);
+}
+
+#[tokio::test]
+async fn poller_wont_poll_until_lang_polls() {
+    let mut mock_client = mock_workflow_client();
+    let (tx, rx) = sync_channel(101);
+    // Normally you'd just not set any expectations, but the problem is since we never poll
+    // the WFT stream, we'll never join the tasks running the pollers and thus the error
+    // gets printed but doesn't bubble up to the test. So we set this explicit expectation
+    // in here to ensure it isn't called.
+    mock_client.expect_poll_workflow_task().returning(move |_| {
+        let _ = tx.send(());
+        Ok(Default::default())
+    });
+
+    let worker = Worker::new_test(
+        test_worker_cfg()
+            .no_remote_activities(true)
+            .build()
+            .unwrap(),
+        mock_client,
+    );
+
+    tokio::time::sleep(Duration::from_millis(100)).await;
+
+    worker.drain_pollers_and_shutdown().await;
+    // Nothing should've appeared here or we did poll
+    assert!(rx.recv().is_err());
+}
+
+#[rstest]
+#[tokio::test]
+async fn use_compatible_version_flag(
+    #[values(
+        VersioningIntent::Unspecified,
+        VersioningIntent::Compatible,
+        VersioningIntent::Default
+    )]
+    intent: VersioningIntent,
+    #[values(true, false)] different_tq: bool,
+    #[values("activity", "child_wf", "continue_as_new")] command_type: &'static str,
+) {
+    let wfid = "fake_wf_id";
+    let mut mock_client = mock_workflow_client();
+    let hist = {
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        t
+    };
+    mock_client.expect_poll_workflow_task().returning(move |_| {
+        Ok(hist_to_poll_resp(&hist, wfid.to_owned(), ResponseType::AllHistory).resp)
+    });
+    let compat_flag_expected = match intent {
+        VersioningIntent::Unspecified => !different_tq,
+        VersioningIntent::Compatible => true,
+        VersioningIntent::Default => false,
+    };
+    mock_client
+        .expect_complete_workflow_task()
+        .returning(move |mut c| {
+            let can_cmd = c.commands.pop().unwrap().attributes.unwrap();
+            match can_cmd {
+                Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(a) => {
+                    assert_eq!(a.use_compatible_version, compat_flag_expected);
+                }
+                Attributes::ScheduleActivityTaskCommandAttributes(a) => {
+                    assert_eq!(a.use_compatible_version, compat_flag_expected);
+                }
+                Attributes::StartChildWorkflowExecutionCommandAttributes(a) => {
+                    assert_eq!(a.use_compatible_version, compat_flag_expected);
+                }
+                _ => panic!("invalid attributes type"),
+            }
+            Ok(Default::default())
+        });
+
+    let worker = Worker::new_test(test_worker_cfg().build().unwrap(), mock_client);
+    let r = worker.poll_workflow_activation().await.unwrap();
+    let task_queue = if different_tq {
+        "enchi cat!".to_string()
+    } else {
+        "".to_string()
+    };
+    let cmd = match command_type {
+        "continue_as_new" => ContinueAsNewWorkflowExecution {
+            workflow_type: "meow".to_string(),
+            versioning_intent: intent as i32,
+            task_queue,
+            ..Default::default()
+        }
+        .into(),
+        "activity" => ScheduleActivity {
+            seq: 1,
+            activity_id: "1".to_string(),
+            versioning_intent: intent as i32,
+            task_queue,
+            ..default_act_sched()
+        }
+        .into(),
+        "child_wf" => StartChildWorkflowExecution {
+            seq: 1,
+            versioning_intent: intent as i32,
+            task_queue,
+            ..Default::default()
+        }
+        .into(),
+        _ => panic!("invalid command type"),
+    };
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(r.run_id, cmd))
+        .await
+        .unwrap();
+}

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

@@ -12,6 +12,7 @@ extern crate tracing;
 extern crate core;
 
 mod abstractions;
+#[cfg(feature = "ephemeral-server")]
 pub mod ephemeral_server;
 mod internal_flags;
 mod pollers;
@@ -82,7 +83,6 @@ where
     let client = {
         let ll = client.into().into_inner();
         let mut client = Client::new(*ll, worker_config.namespace.clone());
-        client.set_worker_build_id(worker_config.worker_build_id.clone());
         if let Some(ref id_override) = worker_config.client_identity_override {
             client.options_mut().identity = id_override.clone();
         }
@@ -147,9 +147,8 @@ pub(crate) fn sticky_q_name_for_worker(
 ) -> Option<String> {
     if config.max_cached_workflows > 0 {
         Some(format!(
-            "{}-{}-{}",
+            "{}-{}",
             &process_identity,
-            &config.task_queue,
             uuid::Uuid::new_v4().simple()
         ))
     } else {

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

@@ -7,12 +7,16 @@ pub use temporal_client::{
     Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig,
     TlsConfig, WorkflowClientTrait,
 };
+
+use crate::abstractions::OwnedMeteredSemPermit;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
     PollActivityTaskQueueResponse, PollWorkflowTaskQueueResponse,
 };
 
 #[cfg(test)]
 use futures::Future;
+#[cfg(test)]
+pub(crate) use poll_buffer::MockPermittedPollBuffer;
 
 pub type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
@@ -31,9 +35,32 @@ where
     /// Need a separate shutdown to be able to consume boxes :(
     async fn shutdown_box(self: Box<Self>);
 }
-pub type BoxedPoller<T> = Box<dyn Poller<T> + Send + Sync + 'static>;
-pub type BoxedWFPoller = BoxedPoller<PollWorkflowTaskQueueResponse>;
-pub type BoxedActPoller = BoxedPoller<PollActivityTaskQueueResponse>;
+pub(crate) type BoxedPoller<T> = Box<dyn Poller<T> + Send + Sync + 'static>;
+pub(crate) type BoxedWFPoller = BoxedPoller<(PollWorkflowTaskQueueResponse, OwnedMeteredSemPermit)>;
+pub(crate) type BoxedActPoller =
+    BoxedPoller<(PollActivityTaskQueueResponse, OwnedMeteredSemPermit)>;
+
+#[async_trait::async_trait]
+impl<T> Poller<T> for Box<dyn Poller<T> + Send + Sync>
+where
+    T: Send + Sync + 'static,
+{
+    async fn poll(&self) -> Option<Result<T>> {
+        Poller::poll(self.as_ref()).await
+    }
+
+    fn notify_shutdown(&self) {
+        Poller::notify_shutdown(self.as_ref())
+    }
+
+    async fn shutdown(self) {
+        Poller::shutdown(self).await
+    }
+
+    async fn shutdown_box(self: Box<Self>) {
+        Poller::shutdown_box(self).await
+    }
+}
 
 #[cfg(test)]
 mockall::mock! {