@temporalio/core-bridge 1.11.8 → 1.12.0

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

@@ -26,6 +26,7 @@ use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_api::{
     Worker as WorkerTrait,
     errors::{CompleteActivityError, PollError},
+    worker::PollerBehavior,
 };
 use temporal_sdk_core_protos::{
     DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
@@ -146,6 +147,7 @@ async fn heartbeats_report_cancels_only_once() {
             Ok(RecordActivityTaskHeartbeatResponse {
                 cancel_requested: true,
                 activity_paused: false,
+                activity_reset: false,
             })
         });
     mock_client
@@ -272,6 +274,7 @@ async fn activity_cancel_interrupts_poll() {
                 Ok(RecordActivityTaskHeartbeatResponse {
                     cancel_requested: true,
                     activity_paused: false,
+                    activity_reset: false,
                 })
             }
             .boxed()
@@ -393,11 +396,13 @@ async fn many_concurrent_heartbeat_cancels() {
                     Ok(RecordActivityTaskHeartbeatResponse {
                         cancel_requested: false,
                         activity_paused: false,
+                        activity_reset: false,
                     })
                 } else {
                     Ok(RecordActivityTaskHeartbeatResponse {
                         cancel_requested: true,
                         activity_paused: false,
+                        activity_reset: false,
                     })
                 }
             }
@@ -408,7 +413,7 @@ async fn many_concurrent_heartbeat_cancels() {
         test_worker_cfg()
             .max_outstanding_activities(CONCURRENCY_NUM)
             // Only 1 poll at a time to avoid over-polling and running out of responses
-            .max_concurrent_at_polls(1_usize)
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
             .build()
             .unwrap(),
         mock_client,
@@ -519,6 +524,7 @@ async fn can_heartbeat_acts_during_shutdown() {
             Ok(RecordActivityTaskHeartbeatResponse {
                 cancel_requested: false,
                 activity_paused: false,
+                activity_reset: false,
             })
         });
     mock_client
@@ -573,6 +579,7 @@ async fn complete_act_with_fail_flushes_heartbeat() {
             Ok(RecordActivityTaskHeartbeatResponse {
                 cancel_requested: false,
                 activity_paused: false,
+                activity_reset: false,
             })
         });
     mock_client
@@ -618,8 +625,8 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
     let mut mock_client = mock_workflow_client();
     mock_client
         .expect_poll_activity_task()
-        .returning(move |_, tps| {
-            assert_eq!(tps, Some(rate));
+        .returning(move |_, ao| {
+            assert_eq!(ao.max_tasks_per_sec, Some(rate));
             Ok(PollActivityTaskQueueResponse {
                 task_token: vec![1],
                 ..Default::default()
@@ -627,7 +634,7 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
         });
 
     let cfg = test_worker_cfg()
-        .max_concurrent_at_polls(1_usize)
+        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
         .max_task_queue_activities_per_second(rate)
         .build()
         .unwrap();
@@ -1081,7 +1088,7 @@ async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
         config: test_worker_cfg()
             .graceful_shutdown_period(grace_period)
             .max_outstanding_activities(max_outstanding)
-            .max_concurrent_at_polls(1_usize) // Makes test logic simple
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize)) // Makes test logic simple
             .build()
             .unwrap(),
         ..Default::default()
@@ -1104,8 +1111,9 @@ async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
         assert_matches!(
             cancel.variant,
             Some(activity_task::Variant::Cancel(Cancel {
-                reason: r
-            })) if r == ActivityCancelReason::WorkerShutdown as i32
+                reason,
+                details
+            })) if reason == ActivityCancelReason::WorkerShutdown as i32 && details.as_ref().is_some_and(|d| d.is_worker_shutdown)
         );
         seen_tts.insert(cancel.task_token);
     }
@@ -1165,7 +1173,7 @@ async fn activities_must_be_flushed_to_server_on_shutdown(#[values(true, false)]
         act_poller: Some(Box::from(mock_act_poller)),
         config: test_worker_cfg()
             .graceful_shutdown_period(grace_period)
-            .max_concurrent_at_polls(1_usize) // Makes test logic simple
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize)) // Makes test logic simple
             .build()
             .unwrap(),
         ..Default::default()
@@ -1240,3 +1248,167 @@ async fn pass_activity_summary_to_metadata() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn heartbeat_response_can_be_paused() {
+    let mut mock_client = mock_workflow_client();
+    // First heartbeat returns pause only
+    mock_client
+        .expect_record_activity_heartbeat()
+        .times(1)
+        .returning(|_, _| {
+            Ok(RecordActivityTaskHeartbeatResponse {
+                cancel_requested: false,
+                activity_paused: true,
+                activity_reset: false,
+            })
+        });
+    // Second heartbeat returns cancel only
+    mock_client
+        .expect_record_activity_heartbeat()
+        .times(1)
+        .returning(|_, _| {
+            Ok(RecordActivityTaskHeartbeatResponse {
+                cancel_requested: true,
+                activity_paused: false,
+                activity_reset: false,
+            })
+        });
+    // Third heartbeat does all 3
+    mock_client
+        .expect_record_activity_heartbeat()
+        .times(1)
+        .returning(|_, _| {
+            Ok(RecordActivityTaskHeartbeatResponse {
+                cancel_requested: true,
+                activity_paused: true,
+                activity_reset: true,
+            })
+        });
+    mock_client
+        .expect_cancel_activity_task()
+        .times(3)
+        .returning(|_, _| Ok(RespondActivityTaskCanceledResponse::default()));
+
+    let core = mock_worker(MocksHolder::from_client_with_activities(
+        mock_client,
+        [
+            PollActivityTaskQueueResponse {
+                task_token: vec![1],
+                activity_id: "act1".to_string(),
+                heartbeat_timeout: Some(prost_dur!(from_millis(1))),
+                ..Default::default()
+            }
+            .into(),
+            PollActivityTaskQueueResponse {
+                task_token: vec![2],
+                activity_id: "act2".to_string(),
+                heartbeat_timeout: Some(prost_dur!(from_millis(1))),
+                ..Default::default()
+            }
+            .into(),
+            PollActivityTaskQueueResponse {
+                task_token: vec![3],
+                activity_id: "act3".to_string(),
+                heartbeat_timeout: Some(prost_dur!(from_millis(1))),
+                ..Default::default()
+            }
+            .into(),
+        ],
+    ));
+
+    // The general testing pattern for each of these cases is:
+    // 1. Poll for activity task
+    // 2. Record activity heartbeat, get mocked heartbeat response
+    // 3. Sleep for 10ms (waiting for heartbeat request to be flushed)
+    // (i.e. sleep enough for the heartbeat flush interval to have elapsed)
+    // 4. Poll for activity task.
+    // We expect a cancellation activity task as they are prioritized (i.e. ordered before)
+    // regular activity tasks.
+    // 5. Assert that the received activity task is indeed a cancellation, with the reason
+    // and details we expect.
+    // 6. Complete the activity with a cancellation result.
+    //
+    // Repeat for subsequent test case(s).
+
+    // Test pause only
+    let act = core.poll_activity_task().await.unwrap();
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: act.task_token.clone(),
+        details: vec![vec![1_u8, 2, 3].into()],
+    });
+    sleep(Duration::from_millis(10)).await;
+    let act = core.poll_activity_task().await.unwrap();
+    assert_matches!(
+        &act,
+        ActivityTask {
+            task_token,
+            variant: Some(activity_task::Variant::Cancel(Cancel { reason, details })),
+        } if
+            task_token == &vec![1] &&
+            *reason == ActivityCancelReason::Paused as i32 &&
+            details.as_ref().is_some_and(|d| d.is_paused) &&
+            details.as_ref().is_some_and(|d| !d.is_cancelled)
+    );
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: act.task_token,
+        result: Some(ActivityExecutionResult::cancel_from_details(None)),
+    })
+    .await
+    .unwrap();
+
+    // Test cancel only
+    let act = core.poll_activity_task().await.unwrap();
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: act.task_token.clone(),
+        details: vec![vec![1_u8, 2, 3].into()],
+    });
+    sleep(Duration::from_millis(10)).await;
+    let act = core.poll_activity_task().await.unwrap();
+    assert_matches!(
+        &act,
+        ActivityTask {
+            task_token,
+            variant: Some(activity_task::Variant::Cancel(Cancel { reason, details })),
+        } if
+            task_token == &vec![2] &&
+            *reason == ActivityCancelReason::Cancelled as i32 &&
+            details.as_ref().is_some_and(|d| !d.is_paused) &&
+            details.as_ref().is_some_and(|d| d.is_cancelled)
+    );
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: act.task_token,
+        result: Some(ActivityExecutionResult::cancel_from_details(None)),
+    })
+    .await
+    .unwrap();
+
+    // Test both pause and cancel (should prioritize cancel)
+    let act = core.poll_activity_task().await.unwrap();
+    core.record_activity_heartbeat(ActivityHeartbeat {
+        task_token: act.task_token.clone(),
+        details: vec![vec![1_u8, 2, 3].into()],
+    });
+    sleep(Duration::from_millis(10)).await;
+    let act = core.poll_activity_task().await.unwrap();
+    assert_matches!(
+        &act,
+        ActivityTask {
+            task_token,
+            variant: Some(activity_task::Variant::Cancel(Cancel { reason, details })),
+        } if
+            task_token == &vec![3] &&
+            *reason == ActivityCancelReason::Cancelled as i32 &&
+            details.as_ref().is_some_and(|d| d.is_paused) &&
+            details.as_ref().is_some_and(|d| d.is_cancelled) &&
+            details.as_ref().is_some_and(|d| d.is_reset)
+    );
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: act.task_token,
+        result: Some(ActivityExecutionResult::cancel_from_details(None)),
+    })
+    .await
+    .unwrap();
+
+    core.drain_activity_poller_and_shutdown().await;
+}

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

@@ -17,7 +17,7 @@ use crate::{
 };
 use futures_util::FutureExt;
 use std::{sync::LazyLock, time::Duration};
-use temporal_sdk_core_api::Worker as WorkerTrait;
+use temporal_sdk_core_api::{Worker as WorkerTrait, worker::PollerBehavior};
 use temporal_sdk_core_protos::coresdk::workflow_completion::WorkflowActivationCompletion;
 use tokio::{sync::Barrier, time::sleep};
 
@@ -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;
@@ -76,8 +76,8 @@ async fn shutdown_interrupts_both_polls() {
     let worker = Worker::new_test(
         test_worker_cfg()
             // Need only 1 concurrent pollers for mock expectations to work here
-            .max_concurrent_wft_polls(1_usize)
-            .max_concurrent_at_polls(1_usize)
+            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
             .build()
             .unwrap(),
         mock_client,

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

@@ -10,7 +10,7 @@ use std::{
     collections::{HashMap, VecDeque},
     time::Duration,
 };
-use temporal_sdk_core_api::Worker as WorkerTrait;
+use temporal_sdk_core_api::{Worker as WorkerTrait, worker::WorkerVersioningStrategy};
 use temporal_sdk_core_protos::{
     TestHistoryBuilder,
     coresdk::{
@@ -881,17 +881,31 @@ async fn build_id_set_properly_on_query_on_first_task() {
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| {
         wc.max_cached_workflows = 10;
-        wc.worker_build_id = "1.0".to_string();
+        wc.versioning_strategy = WorkerVersioningStrategy::None {
+            build_id: "1.0".to_owned(),
+        }
     });
     let core = mock_worker(mock);
 
     let task = core.poll_workflow_activation().await.unwrap();
-    assert_eq!(task.build_id_for_current_task, "1.0");
+    assert_eq!(
+        task.deployment_version_for_current_task
+            .as_ref()
+            .unwrap()
+            .build_id,
+        "1.0"
+    );
     core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
         .await
         .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
-    assert_eq!(task.build_id_for_current_task, "1.0");
+    assert_eq!(
+        task.deployment_version_for_current_task
+            .as_ref()
+            .unwrap()
+            .build_id,
+        "1.0"
+    );
     core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
         .await
         .unwrap();

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

@@ -14,7 +14,7 @@ use crate::{
 };
 use futures_util::{stream, stream::StreamExt};
 use std::{cell::RefCell, time::Duration};
-use temporal_sdk_core_api::Worker;
+use temporal_sdk_core_api::{Worker, worker::PollerBehavior};
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::workflow_activation_job,
@@ -269,11 +269,11 @@ async fn worker_can_shutdown_after_never_polling_ok(#[values(true, false)] poll_
         .returning(|_, _| Err(tonic::Status::permission_denied("you shall not pass")));
     if poll_workflow {
         mock.expect_poll_workflow_task()
-            .returning(|_| Err(tonic::Status::permission_denied("you shall not pass")));
+            .returning(|_, _| Err(tonic::Status::permission_denied("you shall not pass")));
     }
     let core = worker::Worker::new_test(
         test_worker_cfg()
-            .max_concurrent_at_polls(1_usize)
+            .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize))
             .build()
             .unwrap(),
         mock,

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

@@ -1,5 +1,5 @@
 use crate::{
-    Worker, advance_fut,
+    PollWorkflowOptions, Worker, advance_fut,
     internal_flags::CoreInternalFlags,
     job_assert,
     replay::TestHistoryBuilder,
@@ -34,8 +34,8 @@ use temporal_sdk_core_api::{
     Worker as WorkerTrait,
     errors::PollError,
     worker::{
-        SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
-        SlotSupplierPermit, WorkflowSlotKind,
+        PollerBehavior, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
+        SlotSupplier, SlotSupplierPermit, WorkerVersioningStrategy, WorkflowSlotKind,
     },
 };
 use temporal_sdk_core_protos::{
@@ -2056,15 +2056,17 @@ 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());
@@ -2780,7 +2782,7 @@ async fn poller_wont_run_ahead_of_task_slots() {
     let mut mock_client = mock_workflow_client();
     mock_client
         .expect_poll_workflow_task()
-        .returning(move |_| Ok(bunch_of_first_tasks.next().unwrap()));
+        .returning(move |_, _| Ok(bunch_of_first_tasks.next().unwrap()));
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| Ok(Default::default()));
@@ -2789,7 +2791,7 @@ async fn poller_wont_run_ahead_of_task_slots() {
         test_worker_cfg()
             .max_cached_workflows(10_usize)
             .max_outstanding_workflow_tasks(10_usize)
-            .max_concurrent_wft_polls(10_usize)
+            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
             .no_remote_activities(true)
             .build()
             .unwrap(),
@@ -2841,10 +2843,12 @@ async fn poller_wont_poll_until_lang_polls() {
     // 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())
-    });
+    mock_client
+        .expect_poll_workflow_task()
+        .returning(move |_, _| {
+            let _ = tx.send(());
+            Ok(Default::default())
+        });
 
     let worker = Worker::new_test(
         test_worker_cfg()
@@ -2945,6 +2949,7 @@ async fn use_compatible_version_flag(
     worker.shutdown().await;
 }
 
+#[allow(deprecated)]
 #[tokio::test]
 async fn sets_build_id_from_wft_complete() {
     let wfid = "fake_wf_id";
@@ -2973,21 +2978,32 @@ async fn sets_build_id_from_wft_complete() {
     let mut worker = mock_sdk_cfg(
         MockPollCfg::from_resp_batches(wfid, t, [ResponseType::AllHistory], mock),
         |cfg| {
-            cfg.worker_build_id = "fierce-predator".to_string();
+            cfg.versioning_strategy = WorkerVersioningStrategy::None {
+                build_id: "fierce-predator".to_string(),
+            };
             cfg.max_cached_workflows = 1;
         },
     );
 
     worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
         // First task, it should be empty, since replaying and nothing in first WFT completed
-        assert_eq!(ctx.current_build_id(), None);
+        assert_eq!(ctx.current_deployment_version(), None);
         ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.current_build_id(), Some("enchi-cat".to_string()));
+        assert_eq!(
+            ctx.current_deployment_version().unwrap().build_id,
+            "enchi-cat"
+        );
         ctx.timer(Duration::from_secs(1)).await;
         // Not replaying at this point, so we should see the worker's build id
-        assert_eq!(ctx.current_build_id(), Some("fierce-predator".to_string()));
+        assert_eq!(
+            ctx.current_deployment_version().unwrap().build_id,
+            "fierce-predator"
+        );
         ctx.timer(Duration::from_secs(1)).await;
-        assert_eq!(ctx.current_build_id(), Some("fierce-predator".to_string()));
+        assert_eq!(
+            ctx.current_deployment_version().unwrap().build_id,
+            "fierce-predator"
+        );
         Ok(().into())
     });
     worker
@@ -3013,7 +3029,7 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
     let mut mock_client = mock_workflow_client();
     mock_client
         .expect_poll_workflow_task()
-        .returning(move |_| Ok(bunch_of_first_tasks.next().unwrap()));
+        .returning(move |_, _| Ok(bunch_of_first_tasks.next().unwrap()));
     mock_client
         .expect_complete_workflow_task()
         .returning(|_| Ok(Default::default()));
@@ -3043,7 +3059,7 @@ async fn slot_provider_cant_hand_out_more_permits_than_cache_size() {
                     .workflow_slot_supplier(Arc::new(EndlessSupplier {}))
                     .build(),
             ))
-            .max_concurrent_wft_polls(10_usize)
+            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
             .no_remote_activities(true)
             .build()
             .unwrap(),
@@ -3134,3 +3150,153 @@ async fn pass_timer_summary_to_metadata() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn both_normal_and_sticky_pollers_poll_concurrently() {
+    struct Counters {
+        // How many time PollWorkflowTaskQueue has been called
+        normal_poll_count: AtomicUsize,
+        sticky_poll_count: AtomicUsize,
+
+        // How many pollers are currently active (i.e. PollWorkflowTaskQueue
+        // has been called, but not the corresponding CompleteWorkflowTask)
+        normal_slots_active_count: AtomicUsize,
+        sticky_slots_active_count: AtomicUsize,
+
+        // Max number of pollers that were active at the same time
+        max_total_slots_active_count: AtomicUsize,
+        max_normal_slots_active_count: AtomicUsize,
+        max_sticky_slots_active_count: AtomicUsize,
+    }
+
+    let counters = Arc::new(Counters {
+        normal_poll_count: AtomicUsize::new(0),
+        sticky_poll_count: AtomicUsize::new(0),
+        normal_slots_active_count: AtomicUsize::new(0),
+        sticky_slots_active_count: AtomicUsize::new(0),
+        max_total_slots_active_count: AtomicUsize::new(0),
+        max_normal_slots_active_count: AtomicUsize::new(0),
+        max_sticky_slots_active_count: AtomicUsize::new(0),
+    });
+
+    // Create actual workflow task responses to return from polls
+    let mut task_responses = (1..100).map(|i| {
+        hist_to_poll_resp(
+            &canned_histories::single_timer(&format!("timer-{i}")),
+            format!("wf-{i}"),
+            1.into(),
+        )
+        .resp
+    });
+
+    let mut mock_client = mock_workflow_client();
+
+    // Track normal vs sticky poll requests and return actual workflow tasks
+    let cc = Arc::clone(&counters);
+    mock_client
+        .expect_poll_workflow_task()
+        .returning(move |_, opts: PollWorkflowOptions| {
+            let mut task_response = task_responses.next().unwrap_or_default();
+
+            // FIXME: Atomics initially made sense, but this has grown ugly, and there's probably
+            // cases where this may produce incorrect results due to race in operation ordering
+            // (really didn't put any thought into this). We also can't have
+            if opts.sticky_queue_name.is_none() {
+                // Normal queue poll
+                cc.normal_poll_count.fetch_add(1, Ordering::Relaxed);
+                cc.normal_slots_active_count.fetch_add(1, Ordering::Relaxed);
+                cc.max_normal_slots_active_count.fetch_max(
+                    cc.normal_slots_active_count.load(Ordering::Relaxed),
+                    Ordering::AcqRel,
+                );
+                cc.max_total_slots_active_count.fetch_max(
+                    cc.normal_slots_active_count.load(Ordering::Relaxed)
+                        + cc.sticky_slots_active_count.load(Ordering::Relaxed),
+                    Ordering::AcqRel,
+                );
+
+                task_response.task_token = [task_response.task_token, b"normal".to_vec()].concat();
+            } else {
+                // Sticky queue poll
+                cc.sticky_poll_count.fetch_add(1, Ordering::Relaxed);
+                cc.sticky_slots_active_count.fetch_add(1, Ordering::Relaxed);
+                cc.max_sticky_slots_active_count.fetch_max(
+                    cc.sticky_slots_active_count.load(Ordering::Acquire),
+                    Ordering::AcqRel,
+                );
+                cc.max_total_slots_active_count.fetch_max(
+                    cc.normal_slots_active_count.load(Ordering::Relaxed)
+                        + cc.sticky_slots_active_count.load(Ordering::Relaxed),
+                    Ordering::AcqRel,
+                );
+
+                task_response.task_token = [task_response.task_token, b"sticky".to_vec()].concat();
+            }
+
+            // Return actual workflow task responses
+            Ok(task_response)
+        });
+
+    let cc = Arc::clone(&counters);
+    mock_client
+        .expect_complete_workflow_task()
+        .returning(move |completion| {
+            if completion.task_token.0.ends_with(b"normal") {
+                cc.normal_slots_active_count.fetch_sub(1, Ordering::Relaxed);
+            } else {
+                cc.sticky_slots_active_count.fetch_sub(1, Ordering::Relaxed);
+            }
+            Ok(Default::default())
+        });
+
+    let worker = Worker::new(
+        test_worker_cfg()
+            .max_cached_workflows(500_usize) // We need cache, but don't want to deal with evictions
+            .max_outstanding_workflow_tasks(2_usize)
+            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
+            .nonsticky_to_sticky_poll_ratio(0.2)
+            .no_remote_activities(true)
+            .build()
+            .unwrap(),
+        Some("stickytq".to_string()),
+        Arc::new(mock_client),
+        None,
+    );
+
+    for _ in 1..50 {
+        let activation = worker.poll_workflow_activation().await.unwrap();
+        let _ = worker
+            .complete_workflow_activation(WorkflowActivationCompletion::empty(activation.run_id))
+            .await;
+    }
+
+    assert!(
+        counters.normal_poll_count.load(Ordering::Relaxed) > 0,
+        "Normal poller should have been called at least once"
+    );
+    assert!(
+        counters.sticky_poll_count.load(Ordering::Relaxed) > 0,
+        "Sticky poller should have been called at least once"
+    );
+    assert!(
+        counters
+            .max_normal_slots_active_count
+            .load(Ordering::Relaxed)
+            >= 1,
+        "Normal poller should have been active at least once"
+    );
+    assert!(
+        counters
+            .max_sticky_slots_active_count
+            .load(Ordering::Relaxed)
+            >= 1,
+        "Sticky poller should have been active at least once"
+    );
+    assert_eq!(
+        counters
+            .max_total_slots_active_count
+            .load(Ordering::Relaxed),
+        2,
+        "At peak, there should be exactly 2 pollers active at the same time"
+    );
+}