@temporalio/core-bridge 1.14.1 → 1.15.0

package/sdk-core/crates/sdk-core/src/worker/workflow/managed_run.rs

@@ -41,7 +41,6 @@ use temporalio_common::{
             workflow_completion,
         },
         temporal::api::{
-            command::v1::command::Attributes as CmdAttribs,
             enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
             failure::v1::Failure,
         },
@@ -191,6 +190,7 @@ impl ManagedRun {
             attempt = %work.attempt,
             "Applying new workflow task from server"
         );
+        let is_incremental = work.is_incremental();
         let wft_info = WorkflowTaskInfo {
             attempt: work.attempt,
             task_token: work.task_token,
@@ -239,7 +239,9 @@ impl ManagedRun {
 
         // The update field is only populated in the event we hit the cache
         let activation = if work.update.is_real() {
-            self.metrics.sticky_cache_hit();
+            if is_incremental {
+                self.metrics.sticky_cache_hit();
+            }
             self.wfm.new_work_from_server(work.update, work.messages)?
         } else {
             let r = self.wfm.get_next_activation()?;
@@ -440,6 +442,7 @@ impl ManagedRun {
                     action: ActivationAction::RespondLegacyQuery {
                         result: Box::new(qr),
                     },
+                    metrics: self.metrics.clone(),
                 }),
                 resp_chan,
             );
@@ -1127,27 +1130,6 @@ impl ManagedRun {
                 )
             };
 
-            // Record metrics for any outgoing terminal commands
-            for cmd in commands.iter() {
-                match cmd.attributes.as_ref() {
-                    Some(CmdAttribs::CompleteWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_completed();
-                    }
-                    Some(CmdAttribs::FailWorkflowExecutionCommandAttributes(attrs)) => {
-                        if metrics::should_record_failure_metric(&attrs.failure) {
-                            self.metrics.wf_failed();
-                        }
-                    }
-                    Some(CmdAttribs::ContinueAsNewWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_continued_as_new();
-                    }
-                    Some(CmdAttribs::CancelWorkflowExecutionCommandAttributes(_)) => {
-                        self.metrics.wf_canceled();
-                    }
-                    _ => (),
-                }
-            }
-
             let attempt = self.wft.as_ref().map(|t| t.info.attempt).unwrap_or(1);
             ActivationCompleteOutcome::ReportWFTSuccess(ServerCommandsWithWorkflowInfo {
                 task_token: data.task_token,
@@ -1160,6 +1142,7 @@ impl ManagedRun {
                     versioning_behavior: data.versioning_behavior,
                     attempt,
                 },
+                metrics: self.metrics.clone(),
             })
         } else {
             ActivationCompleteOutcome::DoNothing

package/sdk-core/crates/sdk-core/src/worker/workflow/mod.rs

@@ -98,8 +98,7 @@ use tokio::{
     task::{LocalSet, spawn_blocking},
 };
 use tokio_stream::wrappers::UnboundedReceiverStream;
-use tokio_util::either::Either;
-use tokio_util::sync::CancellationToken;
+use tokio_util::{either::Either, sync::CancellationToken};
 use tracing::{Span, Subscriber};
 
 /// Id used by server for "legacy" queries. IE: Queries that come in the `query` rather than
@@ -355,6 +354,7 @@ impl Workflows {
                         mut versioning_behavior,
                         attempt,
                     },
+                metrics: run_metrics,
             } => {
                 let reserved_act_permits =
                     self.reserve_activity_slots_for_outgoing_commands(commands.as_mut_slice());
@@ -372,6 +372,7 @@ impl Workflows {
                     } else {
                         0
                     };
+                let mut maybe_record_terminal_metric = detect_terminal_command(&commands);
                 let mut completion = WorkflowTaskCompletion {
                     task_token: task_token.clone(),
                     commands,
@@ -398,6 +399,9 @@ impl Workflows {
                 self.handle_wft_reporting_errs(run_id, || async {
                     match self.client.complete_workflow_task(completion).await {
                         Ok(response) => {
+                            if let Some(record) = maybe_record_terminal_metric.take() {
+                                record(&run_metrics);
+                            }
                             if response.reset_history_event_id > 0 {
                                 reset_last_started_to = Some(response.reset_history_event_id);
                             }
@@ -460,6 +464,7 @@ impl Workflows {
             ServerCommandsWithWorkflowInfo {
                 task_token,
                 action: ActivationAction::RespondLegacyQuery { result },
+                ..
             } => {
                 self.respond_legacy_query(task_token, LegacyQueryResult::Succeeded(*result))
                     .await;
@@ -1008,10 +1013,18 @@ enum FailedActivationWFTReport {
     ReportLegacyQueryFailure(TaskToken, Failure),
 }
 
-#[derive(Debug)]
 struct ServerCommandsWithWorkflowInfo {
     task_token: TaskToken,
     action: ActivationAction,
+    metrics: MetricsContext,
+}
+impl Debug for ServerCommandsWithWorkflowInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ServerCommandsWithWorkflowInfo")
+            .field("task_token", &self.task_token)
+            .field("action", &self.action)
+            .finish()
+    }
 }
 
 #[derive(Debug)]
@@ -1031,6 +1044,7 @@ pub(crate) enum ActivationAction {
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum EvictionRequestResult {
     EvictionRequested(Option<u32>, RunUpdateAct),
     NotFound,
@@ -1046,6 +1060,35 @@ impl EvictionRequestResult {
     }
 }
 
+#[allow(clippy::type_complexity)]
+fn detect_terminal_command(
+    commands: &[ProtoCommand],
+) -> Option<Box<dyn FnOnce(&MetricsContext) + Send>> {
+    for cmd in commands {
+        match cmd.attributes.as_ref() {
+            Some(Attributes::CompleteWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_completed()));
+            }
+            Some(Attributes::FailWorkflowExecutionCommandAttributes(attrs)) => {
+                let should_record = metrics::should_record_failure_metric(&attrs.failure);
+                return Some(Box::new(move |m: &MetricsContext| {
+                    if should_record {
+                        m.wf_failed();
+                    }
+                }));
+            }
+            Some(Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_continued_as_new()));
+            }
+            Some(Attributes::CancelWorkflowExecutionCommandAttributes(_)) => {
+                return Some(Box::new(|m: &MetricsContext| m.wf_canceled()));
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 #[derive(Debug)]
 #[allow(dead_code)] // Not always used in non-test
 pub(crate) struct WorkflowStateInfo {

package/sdk-core/crates/sdk-core/tests/common/mod.rs

@@ -46,8 +46,7 @@ use temporalio_common::{
         },
     },
     telemetry::{
-        Logger, OtelCollectorOptionsBuilder, PrometheusExporterOptions,
-        PrometheusExporterOptionsBuilder, TelemetryOptions, TelemetryOptionsBuilder,
+        Logger, OtelCollectorOptions, PrometheusExporterOptions, TelemetryOptions,
         metrics::CoreMeter,
     },
     worker::{WorkerTaskTypes, WorkerVersioningStrategy},
@@ -62,8 +61,7 @@ use temporalio_sdk::{
 #[cfg(any(feature = "test-utilities", test))]
 pub(crate) use temporalio_sdk_core::test_help::NAMESPACE;
 use temporalio_sdk_core::{
-    ClientOptions, CoreRuntime, RuntimeOptions, RuntimeOptionsBuilder, WorkerConfig,
-    WorkerConfigBuilder, init_replay_worker, init_worker,
+    ClientOptions, CoreRuntime, RuntimeOptions, WorkerConfig, init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
     test_help::{MockPollCfg, build_mock_pollers, mock_worker},
@@ -101,9 +99,9 @@ pub(crate) async fn init_core_and_create_wf(test_name: &str) -> CoreWfStarter {
     starter
 }
 
-pub(crate) fn integ_worker_config(tq: &str) -> WorkerConfigBuilder {
-    let mut b = WorkerConfigBuilder::default();
-    b.namespace(NAMESPACE)
+pub(crate) fn integ_worker_config(tq: &str) -> WorkerConfig {
+    WorkerConfig::builder()
+        .namespace(env::var(INTEG_NAMESPACE_ENV_VAR).unwrap_or(NAMESPACE.to_string()))
         .task_queue(tq)
         .max_outstanding_activities(100_usize)
         .max_outstanding_local_activities(100_usize)
@@ -112,8 +110,9 @@ pub(crate) fn integ_worker_config(tq: &str) -> WorkerConfigBuilder {
             build_id: "test_build_id".to_owned(),
         })
         .task_types(WorkerTaskTypes::all())
-        .skip_client_worker_set_check(true);
-    b
+        .skip_client_worker_set_check(true)
+        .build()
+        .expect("Configuration options construct properly")
 }
 
 /// Create a worker replay instance preloaded with provided histories. Returns the worker impl.
@@ -129,9 +128,7 @@ where
     I: Stream<Item = HistoryForReplay> + Send + 'static,
 {
     init_integ_telem();
-    let worker_cfg = integ_worker_config(test_name)
-        .build()
-        .expect("Configuration options construct properly");
+    let worker_cfg = integ_worker_config(test_name);
     let worker = init_replay_worker(ReplayWorkerInput::new(worker_cfg, histories))
         .expect("Replay worker must init properly");
     Arc::new(worker)
@@ -177,7 +174,7 @@ pub(crate) fn init_integ_telem() -> Option<&'static CoreRuntime> {
     }
     Some(INTEG_TESTS_RT.get_or_init(|| {
         let telemetry_options = get_integ_telem_options();
-        let runtime_options = RuntimeOptionsBuilder::default()
+        let runtime_options = RuntimeOptions::builder()
             .telemetry_options(telemetry_options)
             .build()
             .expect("Runtime options build cleanly");
@@ -224,7 +221,7 @@ pub(crate) async fn get_cloud_client() -> RetryClient<Client> {
 pub(crate) struct CoreWfStarter {
     /// Used for both the task queue and workflow id
     task_queue_name: String,
-    pub worker_config: WorkerConfigBuilder,
+    pub worker_config: WorkerConfig,
     /// Options to use when starting workflow(s)
     pub workflow_options: WorkflowOptions,
     initted_worker: OnceCell<InitializedWorker>,
@@ -299,9 +296,7 @@ impl CoreWfStarter {
         let task_q_salt = rand_6_chars();
         let task_queue = format!("{test_name}_{task_q_salt}");
         let mut worker_config = integ_worker_config(&task_queue);
-        worker_config
-            .namespace(env::var(INTEG_NAMESPACE_ENV_VAR).unwrap_or(NAMESPACE.to_string()))
-            .max_cached_workflows(1000_usize);
+        worker_config.max_cached_workflows = 1000_usize;
         Self {
             task_queue_name: task_queue,
             worker_config,
@@ -452,10 +447,7 @@ impl CoreWfStarter {
                 } else {
                     init_integ_telem().unwrap()
                 };
-                let cfg = self
-                    .worker_config
-                    .build()
-                    .expect("Worker config must be valid");
+                let cfg = self.worker_config.clone();
                 let client = if let Some(client) = self.client_override.take() {
                     client
                 } else {
@@ -794,41 +786,47 @@ pub(crate) fn get_integ_tls_config() -> Option<TlsOptions> {
 }
 
 pub(crate) fn get_integ_telem_options() -> TelemetryOptions {
-    let mut ob = TelemetryOptionsBuilder::default();
     let filter_string =
         env::var("RUST_LOG").unwrap_or_else(|_| "INFO,temporalio_sdk_core=INFO".to_string());
+
     if let Some(url) = env::var(OTEL_URL_ENV_VAR)
         .ok()
         .map(|x| x.parse::<Url>().unwrap())
     {
-        let opts = OtelCollectorOptionsBuilder::default()
-            .url(url)
+        let opts = OtelCollectorOptions::builder().url(url).build();
+        TelemetryOptions::builder()
+            .metrics(Arc::new(build_otlp_metric_exporter(opts).unwrap()) as Arc<dyn CoreMeter>)
+            .logging(Logger::Console {
+                filter: filter_string,
+            })
             .build()
-            .unwrap();
-        ob.metrics(Arc::new(build_otlp_metric_exporter(opts).unwrap()) as Arc<dyn CoreMeter>);
-    }
-    if let Some(addr) = env::var(PROM_ENABLE_ENV_VAR)
+    } else if let Some(addr) = env::var(PROM_ENABLE_ENV_VAR)
         .ok()
         .map(|x| SocketAddr::new([127, 0, 0, 1].into(), x.parse().unwrap()))
     {
         let prom_info = start_prometheus_metric_exporter(
-            PrometheusExporterOptionsBuilder::default()
+            PrometheusExporterOptions::builder()
                 .socket_addr(addr)
-                .build()
-                .unwrap(),
+                .build(),
         )
         .unwrap();
-        ob.metrics(prom_info.meter as Arc<dyn CoreMeter>);
+        TelemetryOptions::builder()
+            .metrics(prom_info.meter as Arc<dyn CoreMeter>)
+            .logging(Logger::Console {
+                filter: filter_string,
+            })
+            .build()
+    } else {
+        TelemetryOptions::builder()
+            .logging(Logger::Console {
+                filter: filter_string,
+            })
+            .build()
     }
-    ob.logging(Logger::Console {
-        filter: filter_string,
-    })
-    .build()
-    .unwrap()
 }
 
 pub(crate) fn get_integ_runtime_options(telemopts: TelemetryOptions) -> RuntimeOptions {
-    RuntimeOptionsBuilder::default()
+    RuntimeOptions::builder()
         .telemetry_options(telemopts)
         .build()
         .unwrap()
@@ -886,10 +884,9 @@ pub(crate) fn prom_metrics(
     options_override: Option<PrometheusExporterOptions>,
 ) -> (TelemetryOptions, SocketAddr, AbortOnDrop) {
     let prom_exp_opts = options_override.unwrap_or_else(|| {
-        PrometheusExporterOptionsBuilder::default()
+        PrometheusExporterOptions::builder()
             .socket_addr(ANY_PORT.parse().unwrap())
             .build()
-            .unwrap()
     });
     let mut telemopts = get_integ_telem_options();
     let prom_info = start_prometheus_metric_exporter(prom_exp_opts).unwrap();
@@ -998,13 +995,14 @@ impl Drop for ActivationAssertionsInterceptor {
 
 #[cfg(feature = "ephemeral-server")]
 use temporalio_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, TemporalDevServerConfigBuilder, default_cached_download,
+    EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig, default_cached_download,
 };
 
 #[cfg(feature = "ephemeral-server")]
 pub(crate) fn integ_dev_server_config(
     mut extra_args: Vec<String>,
-) -> TemporalDevServerConfigBuilder {
+    ui: bool,
+) -> TemporalDevServerConfig {
     let cli_version = if let Ok(ver_override) = env::var(CLI_VERSION_OVERRIDE_ENV_VAR) {
         EphemeralExe::CachedDownload {
             version: EphemeralExeVersion::Fixed(ver_override.to_owned()),
@@ -1041,7 +1039,9 @@ pub(crate) fn integ_dev_server_config(
         .map(Into::into),
     );
 
-    let mut config = TemporalDevServerConfigBuilder::default();
-    config.exe(cli_version).extra_args(extra_args);
-    config
+    TemporalDevServerConfig::builder()
+        .exe(cli_version)
+        .extra_args(extra_args)
+        .ui(ui)
+        .build()
 }

package/sdk-core/crates/sdk-core/tests/global_metric_tests.rs

@@ -7,7 +7,7 @@ use common::CoreWfStarter;
 use parking_lot::Mutex;
 use std::{sync::Arc, time::Duration};
 use temporalio_common::telemetry::{
-    Logger, OtelCollectorOptionsBuilder, TelemetryOptionsBuilder, metrics::CoreMeter,
+    Logger, OtelCollectorOptions, TelemetryOptions, metrics::CoreMeter,
 };
 use temporalio_sdk_core::{
     CoreRuntime,
@@ -58,28 +58,25 @@ async fn otel_errors_logged_as_errors() {
             .with_env_filter("debug")
             .finish(),
     );
-    let opts = OtelCollectorOptionsBuilder::default()
+    let opts = OtelCollectorOptions::builder()
         .url("https://localhost:12345/v1/metrics".parse().unwrap()) // Nothing bound on that port
-        .build()
-        .unwrap();
+        .build();
     let exporter = build_otlp_metric_exporter(opts).unwrap();
 
     // Global initialization is needed to capture (some) otel logging.
     telemetry_init_global(
-        TelemetryOptionsBuilder::default()
+        TelemetryOptions::builder()
             .subscriber_override(subscriber)
-            .build()
-            .unwrap(),
+            .build(),
     )
     .unwrap();
-    let telemopts = TelemetryOptionsBuilder::default()
+    let telemopts = TelemetryOptions::builder()
         .metrics(Arc::new(exporter) as Arc<dyn CoreMeter>)
         // Importantly, _not_ using subscriber override, is using console.
         .logging(Logger::Console {
             filter: construct_filter_string(Level::INFO, Level::WARN),
         })
-        .build()
-        .unwrap();
+        .build();
 
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("otel_errors_logged_as_errors", rt);

package/sdk-core/crates/sdk-core/tests/heavy_tests/fuzzy_workflow.rs

@@ -77,11 +77,9 @@ async fn fuzzy_workflow() {
     let num_workflows = 200;
     let wf_name = "fuzzy_wf";
     let mut starter = CoreWfStarter::new("fuzzy_workflow");
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(25_usize)
-        .max_cached_workflows(25_usize)
-        .max_outstanding_activities(25_usize);
+    starter.worker_config.max_outstanding_workflow_tasks = Some(25);
+    starter.worker_config.max_cached_workflows = 25;
+    starter.worker_config.max_outstanding_activities = Some(25);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), fuzzy_wf_def);
     worker.register_activity("echo_activity", echo);

package/sdk-core/crates/sdk-core/tests/heavy_tests.rs

@@ -40,12 +40,10 @@ async fn activity_load() {
     const CONCURRENCY: usize = 512;
 
     let mut starter = CoreWfStarter::new("activity_load");
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(CONCURRENCY)
-        .max_cached_workflows(CONCURRENCY)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .max_outstanding_activities(CONCURRENCY);
+    starter.worker_config.max_outstanding_workflow_tasks = Some(CONCURRENCY);
+    starter.worker_config.max_cached_workflows = CONCURRENCY;
+    starter.worker_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10);
+    starter.worker_config.max_outstanding_activities = Some(CONCURRENCY);
     let mut worker = starter.worker().await;
 
     let activity_id = "act-1";
@@ -110,11 +108,12 @@ async fn chunky_activities_resource_based() {
     const WORKFLOWS: usize = 100;
 
     let mut starter = CoreWfStarter::new("chunky_activities_resource_based");
-    starter
-        .worker_config
-        .clear_max_outstanding_opts()
-        .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize));
+    starter.worker_config.max_outstanding_workflow_tasks = None;
+    starter.worker_config.max_outstanding_local_activities = None;
+    starter.worker_config.max_outstanding_activities = None;
+    starter.worker_config.max_outstanding_nexus_tasks = None;
+    starter.worker_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
+    starter.worker_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10_usize);
     let mut tuner = ResourceBasedTuner::new(0.7, 0.7);
     tuner
         .with_workflow_slots_options(ResourceSlotOptions::new(
@@ -123,7 +122,7 @@ async fn chunky_activities_resource_based() {
             Duration::from_millis(0),
         ))
         .with_activity_slots_options(ResourceSlotOptions::new(5, 1000, Duration::from_millis(50)));
-    starter.worker_config.tuner(Arc::new(tuner));
+    starter.worker_config.tuner = Some(Arc::new(tuner));
     let mut worker = starter.worker().await;
 
     let activity_id = "act-1";
@@ -174,6 +173,7 @@ async fn chunky_activities_resource_based() {
                     wf_type.to_owned(),
                     vec![],
                     WorkflowOptions {
+                        #[allow(deprecated)]
                         id_reuse_policy: WorkflowIdReusePolicy::TerminateIfRunning,
                         ..Default::default()
                     },
@@ -203,12 +203,10 @@ async fn workflow_load() {
     init_integ_telem();
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("workflow_load", rt);
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(5_usize)
-        .max_cached_workflows(200_usize)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(10_usize))
-        .max_outstanding_activities(100_usize);
+    starter.worker_config.max_outstanding_workflow_tasks = Some(5);
+    starter.worker_config.max_cached_workflows = 200;
+    starter.worker_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(10);
+    starter.worker_config.max_outstanding_activities = Some(100);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
@@ -282,10 +280,8 @@ async fn workflow_load() {
 async fn evict_while_la_running_no_interference() {
     let wf_name = "evict_while_la_running_no_interference";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .max_outstanding_local_activities(20_usize)
-        .max_cached_workflows(20_usize);
+    starter.worker_config.max_outstanding_local_activities = Some(20);
+    starter.worker_config.max_cached_workflows = 20;
     // Though it doesn't make sense to set wft higher than cached workflows, leaving this commented
     // introduces more instability that can be useful in the test.
     // starter.max_wft(20);
@@ -350,11 +346,9 @@ pub async fn many_parallel_timers_longhist(ctx: WfContext) -> WorkflowResult<()>
 async fn can_paginate_long_history() {
     let wf_name = "can_paginate_long_history";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only())
-        // Do not use sticky queues so we are forced to paginate once history gets long
-        .max_cached_workflows(0_usize);
+    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
+    // Do not use sticky queues so we are forced to paginate once history gets long
+    starter.worker_config.max_cached_workflows = 0;
 
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), many_parallel_timers_longhist);
@@ -394,21 +388,19 @@ async fn poller_autoscaling_basic_loadtest() {
     let num_workflows = 100;
     let wf_name = "poller_load";
     let mut starter = CoreWfStarter::new("poller_load");
-    starter
-        .worker_config
-        .max_cached_workflows(5000_usize)
-        .max_outstanding_workflow_tasks(1000_usize)
-        .max_outstanding_activities(1000_usize)
-        .workflow_task_poller_behavior(PollerBehavior::Autoscaling {
-            minimum: 1,
-            maximum: 200,
-            initial: 5,
-        })
-        .activity_task_poller_behavior(PollerBehavior::Autoscaling {
-            minimum: 1,
-            maximum: 200,
-            initial: 5,
-        });
+    starter.worker_config.max_cached_workflows = 5000;
+    starter.worker_config.max_outstanding_workflow_tasks = Some(1000);
+    starter.worker_config.max_outstanding_activities = Some(1000);
+    starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+        minimum: 1,
+        maximum: 200,
+        initial: 5,
+    };
+    starter.worker_config.activity_task_poller_behavior = PollerBehavior::Autoscaling {
+        minimum: 1,
+        maximum: 200,
+        initial: 5,
+    };
     let mut worker = starter.worker().await;
     let shutdown_handle = worker.inner_mut().shutdown_handle();
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {