@temporalio/core-bridge 1.11.2 → 1.11.4

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/core_interface.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package coresdk;
-option ruby_package = "Temporalio::Bridge::Api::CoreInterface";
+option ruby_package = "Temporalio::Internal::Bridge::Api::CoreInterface";
 
 // Note: Intellij will think the Google imports don't work because of the slightly odd nature of
 // the include paths. You can make it work by going to the "Protobuf Support" settings section
@@ -29,3 +29,19 @@ message ActivityTaskCompletion {
     bytes task_token = 1;
     activity_result.ActivityExecutionResult result = 2;
 }
+
+// Info about workflow task slot usage
+message WorkflowSlotInfo {
+    string workflow_type = 1;
+    bool is_sticky = 2;
+}
+
+// Info about activity task slot usage
+message ActivitySlotInfo {
+    string activity_type = 1;
+}
+
+// Info about local activity slot usage
+message LocalActivitySlotInfo {
+    string activity_type = 1;
+}

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/external_data/external_data.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package coresdk.external_data;
-option ruby_package = "Temporalio::Bridge::Api::ExternalData";
+option ruby_package = "Temporalio::Internal::Bridge::Api::ExternalData";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -5,7 +5,7 @@ syntax = "proto3";
  * lang SDK applies these activation jobs to drive workflows.
  */
 package coresdk.workflow_activation;
-option ruby_package = "Temporalio::Bridge::Api::WorkflowActivation";
+option ruby_package = "Temporalio::Internal::Bridge::Api::WorkflowActivation";
 
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/duration.proto";

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/workflow_commands/workflow_commands.proto

@@ -6,7 +6,7 @@ syntax = "proto3";
  * activation.
  */
 package coresdk.workflow_commands;
-option ruby_package = "Temporalio::Bridge::Api::WorkflowCommands";
+option ruby_package = "Temporalio::Internal::Bridge::Api::WorkflowCommands";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/workflow_completion/workflow_completion.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package coresdk.workflow_completion;
-option ruby_package = "Temporalio::Bridge::Api::WorkflowCompletion";
+option ruby_package = "Temporalio::Internal::Bridge::Api::WorkflowCompletion";
 
 import "temporal/api/failure/v1/message.proto";
 import "temporal/api/enums/v1/failed_cause.proto";

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

@@ -111,6 +111,7 @@ pub mod coresdk {
             temporal::api::enums::v1::TimeoutType,
         };
         use activity_execution_result as aer;
+        use anyhow::anyhow;
         use std::fmt::{Display, Formatter};
 
         impl ActivityExecutionResult {
@@ -209,13 +210,23 @@ pub mod coresdk {
         }
 
         impl ActivityResolution {
-            pub fn unwrap_ok_payload(self) -> Payload {
-                match self.status.unwrap() {
-                    activity_resolution::Status::Completed(c) => c.result.unwrap(),
-                    e => panic!("Activity was not successful: {e:?}"),
+            /// Extract an activity's payload if it completed successfully, or return an error for all
+            /// other outcomes.
+            pub fn success_payload_or_error(self) -> Result<Option<Payload>, anyhow::Error> {
+                let Some(status) = self.status else {
+                    return Err(anyhow!("Activity completed without a status"));
+                };
+
+                match status {
+                    activity_resolution::Status::Completed(success) => Ok(success.result),
+                    e => Err(anyhow!("Activity was not successful: {e:?}")),
                 }
             }
 
+            pub fn unwrap_ok_payload(self) -> Payload {
+                self.success_payload_or_error().unwrap().unwrap()
+            }
+
             pub fn completed_ok(&self) -> bool {
                 matches!(self.status, Some(activity_resolution::Status::Completed(_)))
             }
@@ -1447,6 +1458,11 @@ pub mod coresdk {
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
+        pub mod activity {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.activity.v1");
+            }
+        }
         pub mod batch {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.batch.v1");
@@ -1754,9 +1770,11 @@ pub mod temporal {
                     }
                 }
 
-                impl Display for Payload {
+                impl std::fmt::Debug for Payload {
                     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                        if self.data.len() > 64 {
+                        if std::env::var("TEMPORAL_PRINT_FULL_PAYLOADS").is_err()
+                            && self.data.len() > 64
+                        {
                             let mut windows = self.data.as_slice().windows(32);
                             write!(
                                 f,
@@ -1770,6 +1788,12 @@ pub mod temporal {
                     }
                 }
 
+                impl Display for Payload {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        write!(f, "{:?}", self)
+                    }
+                }
+
                 impl Display for Header {
                     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                         write!(f, "Header(")?;

package/sdk-core/test-utils/Cargo.toml

@@ -18,9 +18,8 @@ anyhow = "1.0"
 async-trait = "0.1"
 base64 = "0.22"
 bytes = "1.3"
-futures = "0.3"
+futures-util = { version = "0.3", default-features = false }
 log = "0.4"
-once_cell = { workspace = true }
 parking_lot = "0.12"
 prost = { workspace = true }
 prost-types = { workspace = true }

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

@@ -13,7 +13,7 @@ pub use temporal_sdk_core::replay::HistoryForReplay;
 use crate::stream::{Stream, TryStreamExt};
 use anyhow::{Context, Error};
 use base64::{prelude::BASE64_STANDARD, Engine};
-use futures::{future, stream, stream::FuturesUnordered, StreamExt};
+use futures_util::{future, stream, stream::FuturesUnordered, StreamExt};
 use parking_lot::Mutex;
 use prost::Message;
 use rand::{distributions::Standard, Rng};
@@ -154,7 +154,7 @@ pub async fn history_from_proto_binary(path_from_root: &str) -> Result<History,
     Ok(History::decode(&*bytes)?)
 }
 
-static INTEG_TESTS_RT: once_cell::sync::OnceCell<CoreRuntime> = once_cell::sync::OnceCell::new();
+static INTEG_TESTS_RT: std::sync::OnceLock<CoreRuntime> = std::sync::OnceLock::new();
 pub fn init_integ_telem() -> &'static CoreRuntime {
     INTEG_TESTS_RT.get_or_init(|| {
         let telemetry_options = get_integ_telem_options();

package/sdk-core/tests/heavy_tests.rs

@@ -1,4 +1,4 @@
-use futures::{future::join_all, sink, stream::FuturesUnordered, StreamExt};
+use futures_util::{future::join_all, sink, stream::FuturesUnordered, StreamExt};
 use std::{
     sync::Arc,
     time::{Duration, Instant},

package/sdk-core/tests/integ_tests/ephemeral_server_tests.rs

@@ -1,5 +1,5 @@
-use futures::stream;
-use futures::TryStreamExt;
+use futures_util::stream;
+use futures_util::TryStreamExt;
 use std::time::{SystemTime, UNIX_EPOCH};
 use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
 use temporal_sdk_core::ephemeral_server::{

package/sdk-core/tests/integ_tests/metrics_tests.rs

@@ -1,10 +1,14 @@
+use anyhow::anyhow;
 use assert_matches::assert_matches;
 use std::{env, net::SocketAddr, sync::Arc, time::Duration};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporal_sdk::{
+    ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions, WfContext,
+};
 use temporal_sdk_core::{
     init_worker,
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
-    CoreRuntime,
+    CoreRuntime, TokioRuntimeBuilder,
 };
 use temporal_sdk_core_api::{
     telemetry::{
@@ -25,9 +29,10 @@ use temporal_sdk_core_protos::{
             ScheduleActivity, ScheduleLocalActivity,
         },
         workflow_completion::WorkflowActivationCompletion,
-        ActivityTaskCompletion,
+        ActivityTaskCompletion, AsJsonPayloadExt,
     },
     temporal::api::{
+        common::v1::RetryPolicy,
         enums::v1::WorkflowIdReusePolicy,
         failure::v1::Failure,
         query::v1::WorkflowQuery,
@@ -491,11 +496,8 @@ async fn query_of_closed_workflow_doesnt_tick_terminal_metric(
 
 #[test]
 fn runtime_new() {
-    let mut rt = CoreRuntime::new(
-        get_integ_telem_options(),
-        tokio::runtime::Builder::new_multi_thread(),
-    )
-    .unwrap();
+    let mut rt =
+        CoreRuntime::new(get_integ_telem_options(), TokioRuntimeBuilder::default()).unwrap();
     let handle = rt.tokio_handle();
     let _rt = handle.enter();
     let (telemopts, addr, _aborter) = prom_metrics(false, false);
@@ -620,3 +622,138 @@ async fn request_fail_codes_otel() {
         tokio::time::sleep(Duration::from_secs(1)).await;
     }
 }
+
+#[tokio::test]
+async fn activity_metrics() {
+    let (telemopts, addr, _aborter) = prom_metrics(false, false);
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let wf_name = "activity_metrics";
+    let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
+    let task_queue = starter.get_task_queue().to_owned();
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_string(), |ctx: WfContext| async move {
+        let normal_act_pass = ctx.activity(ActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "pass".as_json_payload().expect("serializes fine"),
+            start_to_close_timeout: Some(Duration::from_secs(1)),
+            ..Default::default()
+        });
+        let local_act_pass = ctx.local_activity(LocalActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "pass".as_json_payload().expect("serializes fine"),
+            ..Default::default()
+        });
+        let normal_act_fail = ctx.activity(ActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "fail".as_json_payload().expect("serializes fine"),
+            start_to_close_timeout: Some(Duration::from_secs(1)),
+            retry_policy: Some(RetryPolicy {
+                maximum_attempts: 1,
+                ..Default::default()
+            }),
+            ..Default::default()
+        });
+        let local_act_fail = ctx.local_activity(LocalActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "fail".as_json_payload().expect("serializes fine"),
+            retry_policy: RetryPolicy {
+                maximum_attempts: 1,
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+        let local_act_cancel = ctx.local_activity(LocalActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "cancel".as_json_payload().expect("serializes fine"),
+            retry_policy: RetryPolicy {
+                maximum_attempts: 1,
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+        join!(
+            normal_act_pass,
+            local_act_pass,
+            normal_act_fail,
+            local_act_fail
+        );
+        local_act_cancel.cancel(&ctx);
+        local_act_cancel.await;
+        Ok(().into())
+    });
+    worker.register_activity("pass_fail_act", |ctx: ActContext, i: String| async move {
+        match i.as_str() {
+            "pass" => Ok("pass"),
+            "cancel" => {
+                // TODO: Cancel is taking until shutdown to come through :|
+                ctx.cancelled().await;
+                Err(ActivityError::cancelled())
+            }
+            _ => Err(anyhow!("fail").into()),
+        }
+    });
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    assert!(body.contains(&format!(
+        "temporal_activity_execution_failed{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",workflow_type=\"{wf_name}\"}} 1"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_activity_schedule_to_start_latency_count{{\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\"}} 2"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_activity_execution_latency_count{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",workflow_type=\"{wf_name}\"}} 2"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_activity_succeed_endtoend_latency_count{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",workflow_type=\"{wf_name}\"}} 1"
+    )));
+
+    assert!(body.contains(&format!(
+        "temporal_local_activity_total{{activity_type=\"pass_fail_act\",namespace=\"{NAMESPACE}\",\
+             service_name=\"temporal-core-sdk\",task_queue=\"{task_queue}\",\
+             workflow_type=\"{wf_name}\"}} 3"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_local_activity_execution_failed{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",\
+             workflow_type=\"{wf_name}\"}} 1"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_local_activity_execution_cancelled{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",\
+             workflow_type=\"{wf_name}\"}} 1"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_local_activity_execution_latency_count{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",\
+             workflow_type=\"{wf_name}\"}} 3"
+    )));
+    assert!(body.contains(&format!(
+        "temporal_local_activity_succeed_endtoend_latency_count{{activity_type=\"pass_fail_act\",\
+             namespace=\"{NAMESPACE}\",service_name=\"temporal-core-sdk\",\
+             task_queue=\"{task_queue}\",\
+             workflow_type=\"{wf_name}\"}} 1"
+    )));
+}

package/sdk-core/tests/integ_tests/queries_tests.rs

@@ -1,6 +1,6 @@
 use assert_matches::assert_matches;
-use futures::{prelude::stream::FuturesUnordered, FutureExt, StreamExt};
 use futures_util::future::join_all;
+use futures_util::{stream::FuturesUnordered, FutureExt, StreamExt};
 use std::time::{Duration, Instant};
 use temporal_client::WorkflowClientTrait;
 use temporal_sdk_core_protos::{

package/sdk-core/tests/integ_tests/update_tests.rs

@@ -1,11 +1,10 @@
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use futures_util::{future, future::join_all, StreamExt};
-use once_cell::sync::Lazy;
 use std::{
     sync::{
         atomic::{AtomicBool, AtomicUsize, Ordering},
-        Arc,
+        Arc, LazyLock,
     },
     time::Duration,
 };
@@ -78,7 +77,13 @@ async fn update_workflow(#[values(FailUpdate::Yes, FailUpdate::No)] will_fail: F
         .unwrap();
     let with_id = HistoryForReplay::new(history, workflow_id.to_string());
     let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
-    handle_update(will_fail, CompleteWorkflow::Yes, replay_worker.as_ref(), 1).await;
+    // Init workflow comes by itself
+    let act = replay_worker.poll_workflow_activation().await.unwrap();
+    replay_worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
+        .await
+        .unwrap();
+    handle_update(will_fail, CompleteWorkflow::Yes, replay_worker.as_ref(), 0).await;
 }
 
 #[tokio::test]
@@ -147,6 +152,12 @@ async fn reapplied_updates_due_to_reset() {
     let with_id = HistoryForReplay::new(history, workflow_id.to_string());
 
     let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
+    // Init workflow comes by itself
+    let act = replay_worker.poll_workflow_activation().await.unwrap();
+    replay_worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
+        .await
+        .unwrap();
     // We now recapitulate the actions that the worker took on first execution above, pretending
     // that we always followed the post-reset history.
     // First, we handled the post-reset reapplied update and did not complete the workflow.
@@ -154,9 +165,15 @@ async fn reapplied_updates_due_to_reset() {
         FailUpdate::No,
         CompleteWorkflow::No,
         replay_worker.as_ref(),
-        2,
+        1,
     )
     .await;
+    // Then the timer fires
+    let act = replay_worker.poll_workflow_activation().await.unwrap();
+    replay_worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
+        .await
+        .unwrap();
     // Then the client sent a second update; we handled it and completed the workflow.
     handle_update(
         FailUpdate::No,
@@ -957,7 +974,7 @@ async fn worker_restarted_in_middle_of_update() {
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
 
-    static BARR: Lazy<Barrier> = Lazy::new(|| Barrier::new(2));
+    static BARR: LazyLock<Barrier> = LazyLock::new(|| Barrier::new(2));
     static ACT_RAN: AtomicBool = AtomicBool::new(false);
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         ctx.update_handler(
@@ -1044,3 +1061,90 @@ async fn worker_restarted_in_middle_of_update() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn update_after_empty_wft() {
+    let wf_name = "update_after_empty_wft";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+    let client = starter.get_client().await;
+
+    static ACT_STARTED: AtomicBool = AtomicBool::new(false);
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        ctx.update_handler(
+            "update",
+            |_: &_, _: ()| Ok(()),
+            move |ctx: UpdateContext, _: ()| async move {
+                if ACT_STARTED.load(Ordering::Acquire) {
+                    return Ok(());
+                }
+                ctx.wf_ctx
+                    .activity(ActivityOptions {
+                        activity_type: "echo".to_string(),
+                        input: "hi!".as_json_payload().expect("serializes fine"),
+                        start_to_close_timeout: Some(Duration::from_secs(2)),
+                        ..Default::default()
+                    })
+                    .await;
+                Ok(())
+            },
+        );
+        let mut sig = ctx.make_signal_channel("signal");
+        let sig_handle = async {
+            sig.next().await;
+            ACT_STARTED.store(true, Ordering::Release);
+            ctx.activity(ActivityOptions {
+                activity_type: "echo".to_string(),
+                input: "hi!".as_json_payload().expect("serializes fine"),
+                start_to_close_timeout: Some(Duration::from_secs(2)),
+                ..Default::default()
+            })
+            .await;
+            ACT_STARTED.store(false, Ordering::Release);
+        };
+        join!(sig_handle, async {
+            ctx.timer(Duration::from_secs(2)).await;
+        });
+        Ok(().into())
+    });
+    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
+        Ok(echo_me)
+    });
+
+    let run_id = starter.start_with_worker(wf_name, &mut worker).await;
+    let wf_id = starter.get_task_queue().to_string();
+    let update = async {
+        client
+            .signal_workflow_execution(
+                wf_id.clone(),
+                "".to_string(),
+                "signal".to_string(),
+                None,
+                None,
+            )
+            .await
+            .unwrap();
+        tokio::time::sleep(Duration::from_millis(500)).await;
+        let res = client
+            .update_workflow_execution(
+                wf_id.clone(),
+                "".to_string(),
+                "update".to_string(),
+                WaitPolicy {
+                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
+                },
+                [().as_json_payload().unwrap()].into_payloads(),
+            )
+            .await
+            .unwrap();
+        assert!(res.outcome.unwrap().is_success());
+    };
+    let runner = async {
+        worker.run_until_done().await.unwrap();
+    };
+    join!(update, runner);
+    starter
+        .fetch_history_and_replay(wf_id, run_id, worker.inner_mut())
+        .await
+        .unwrap();
+}

package/sdk-core/tests/integ_tests/worker_tests.rs

@@ -1,15 +1,15 @@
-use std::cell::Cell;
-use std::sync::Arc;
-
 use assert_matches::assert_matches;
+use std::{cell::Cell, sync::Arc, time::Duration};
 use temporal_client::WorkflowOptions;
-use temporal_sdk::interceptors::WorkerInterceptor;
-use temporal_sdk_core::{init_worker, CoreRuntime};
+use temporal_sdk::{interceptors::WorkerInterceptor, WfContext};
+use temporal_sdk_core::{init_worker, CoreRuntime, ResourceBasedTuner, ResourceSlotOptions};
 use temporal_sdk_core_api::{errors::WorkerValidationError, worker::WorkerConfigBuilder, Worker};
-use temporal_sdk_core_protos::coresdk::workflow_completion::{
-    workflow_activation_completion::Status, Failure, WorkflowActivationCompletion,
+use temporal_sdk_core_protos::{
+    coresdk::workflow_completion::{
+        workflow_activation_completion::Status, Failure, WorkflowActivationCompletion,
+    },
+    temporal::api::failure::v1::Failure as InnerFailure,
 };
-use temporal_sdk_core_protos::temporal::api::failure::v1::Failure as InnerFailure;
 use temporal_sdk_core_test_utils::{
     drain_pollers_and_shutdown, get_integ_server_options, get_integ_telem_options, CoreWfStarter,
 };
@@ -111,3 +111,39 @@ async fn worker_handles_unknown_workflow_types_gracefully() {
         drain_pollers_and_shutdown(&worker).await;
     });
 }
+
+#[tokio::test]
+async fn resource_based_few_pollers_guarantees_non_sticky_poll() {
+    let wf_name = "resource_based_few_pollers_guarantees_non_sticky_poll";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter
+        .worker_config
+        .clear_max_outstanding_opts()
+        .no_remote_activities(true)
+        // 3 pollers so the minimum slots of 2 can both be handed out to a sticky poller
+        .max_concurrent_wft_polls(3_usize);
+    // Set the limits to zero so it's essentially unwilling to hand out slots
+    let mut tuner = ResourceBasedTuner::new(0.0, 0.0);
+    tuner.with_workflow_slots_options(ResourceSlotOptions::new(2, 10, Duration::from_millis(0)));
+    starter.worker_config.tuner(Arc::new(tuner));
+    let mut worker = starter.worker().await;
+
+    // Workflow doesn't actually need to do anything. We just need to see that we don't get stuck
+    // by assigning all slots to sticky pollers.
+    worker.register_wf(
+        wf_name.to_owned(),
+        |_: WfContext| async move { Ok(().into()) },
+    );
+    for i in 0..20 {
+        worker
+            .submit_wf(
+                format!("{wf_name}_{i}"),
+                wf_name.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+    }
+    worker.run_until_done().await.unwrap();
+}

package/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs

@@ -1,6 +1,6 @@
 use crate::integ_tests::activity_functions::echo;
 use anyhow::anyhow;
-use futures::future::join_all;
+use futures_util::future::join_all;
 use std::{
     sync::atomic::{AtomicU8, Ordering},
     time::Duration,

package/sdk-core/tests/integ_tests/workflow_tests/resets.rs

@@ -1,5 +1,5 @@
 use crate::integ_tests::activity_functions::echo;
-use futures::StreamExt;
+use futures_util::StreamExt;
 use std::{
     sync::{
         atomic::{AtomicBool, AtomicU64, Ordering},

package/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use futures::StreamExt;
+use futures_util::StreamExt;
 use temporal_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -18,7 +18,8 @@ mod upsert_search_attrs;
 
 use crate::integ_tests::{activity_functions::echo, metrics_tests};
 use assert_matches::assert_matches;
-use futures::{channel::mpsc::UnboundedReceiver, future, SinkExt, StreamExt};
+use futures_channel::mpsc::UnboundedReceiver;
+use futures_util::{future, SinkExt, StreamExt};
 use std::{
     collections::{HashMap, HashSet},
     sync::{
@@ -92,7 +93,7 @@ async fn parallel_workflows_same_queue() {
     let handles: Vec<_> = run_ids
         .iter()
         .map(|run_id| {
-            let (tx, rx) = futures::channel::mpsc::unbounded();
+            let (tx, rx) = futures_channel::mpsc::unbounded();
             send_chans.insert(run_id.clone(), tx);
             tokio::spawn(wf_task(core.clone(), rx))
         })