@temporalio/core-bridge 1.14.1 → 1.15.0

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

@@ -4,7 +4,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use temporalio_client::{ClientOptions, TestService, WorkflowService};
 use temporalio_common::protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
 use temporalio_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
+    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfig,
     default_cached_download,
 };
 use tonic::IntoRequest;
@@ -12,10 +12,9 @@ use url::Url;
 
 #[tokio::test]
 async fn temporal_cli_default() {
-    let config = TemporalDevServerConfigBuilder::default()
+    let config = TemporalDevServerConfig::builder()
         .exe(default_cached_download())
-        .build()
-        .unwrap();
+        .build();
     let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
 
@@ -28,10 +27,9 @@ async fn temporal_cli_default() {
 
 #[tokio::test]
 async fn temporal_cli_fixed() {
-    let config = TemporalDevServerConfigBuilder::default()
+    let config = TemporalDevServerConfig::builder()
         .exe(fixed_cached_download("v1.2.0"))
-        .build()
-        .unwrap();
+        .build();
     let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
     server.shutdown().await.unwrap();
@@ -41,11 +39,10 @@ async fn temporal_cli_fixed() {
 async fn temporal_cli_shutdown_port_reuse() {
     // Start, test shutdown, do again immediately on same port to ensure we can
     // reuse after shutdown
-    let config = TemporalDevServerConfigBuilder::default()
+    let config = TemporalDevServerConfig::builder()
         .exe(default_cached_download())
-        .port(Some(10123))
-        .build()
-        .unwrap();
+        .port(10123)
+        .build();
     let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
     server.shutdown().await.unwrap();
@@ -66,10 +63,11 @@ async fn temporal_cli_shutdown_port_reuse() {
 #[ignore]
 async fn temporal_cli_concurrent_starts() -> Result<(), Box<dyn std::error::Error>> {
     stream::iter((0..80).map(|_| {
-        TemporalDevServerConfigBuilder::default()
-            .exe(default_cached_download())
-            .build()
-            .map_err(anyhow::Error::from)
+        Ok::<TemporalDevServerConfig, Box<dyn std::error::Error>>(
+            TemporalDevServerConfig::builder()
+                .exe(default_cached_download())
+                .build(),
+        )
     }))
     .try_for_each_concurrent(8, |config| async move {
         let mut server = config.start_server().await?;
@@ -85,14 +83,13 @@ async fn temporal_cli_concurrent_starts() -> Result<(), Box<dyn std::error::Erro
 #[cfg(not(all(target_os = "linux", any(target_arch = "arm", target_arch = "aarch64"))))]
 mod test_server {
     use super::*;
-    use temporalio_sdk_core::ephemeral_server::TestServerConfigBuilder;
+    use temporalio_sdk_core::ephemeral_server::TestServerConfig;
 
     #[tokio::test]
     async fn test_server_default() {
-        let config = TestServerConfigBuilder::default()
+        let config = TestServerConfig::builder()
             .exe(default_cached_download())
-            .build()
-            .unwrap();
+            .build();
         let mut server = config.start_server().await.unwrap();
         assert_ephemeral_server(&server).await;
         server.shutdown().await.unwrap();
@@ -100,10 +97,9 @@ mod test_server {
 
     #[tokio::test]
     async fn test_server_fixed() {
-        let config = TestServerConfigBuilder::default()
+        let config = TestServerConfig::builder()
             .exe(fixed_cached_download("v1.16.0"))
-            .build()
-            .unwrap();
+            .build();
         let mut server = config.start_server().await.unwrap();
         assert_ephemeral_server(&server).await;
         server.shutdown().await.unwrap();
@@ -113,11 +109,10 @@ mod test_server {
     async fn test_server_shutdown_port_reuse() {
         // Start, test shutdown, do again immediately on same port to ensure we can
         // reuse after shutdown
-        let config = TestServerConfigBuilder::default()
+        let config = TestServerConfig::builder()
             .exe(default_cached_download())
-            .port(Some(10124))
-            .build()
-            .unwrap();
+            .port(10124)
+            .build();
         let mut server = config.start_server().await.unwrap();
         assert_ephemeral_server(&server).await;
         server.shutdown().await.unwrap();

package/sdk-core/crates/sdk-core/tests/integ_tests/heartbeat_tests.rs

@@ -72,6 +72,7 @@ async fn activity_heartbeat() {
     let response_payload = Payload {
         data: b"hello ".to_vec(),
         metadata: Default::default(),
+        external_payloads: Default::default(),
     };
     // Complete activity successfully.
     core.complete_activity_task(ActivityTaskCompletion {

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

@@ -48,17 +48,17 @@ use temporalio_common::{
         },
     },
     telemetry::{
-        HistogramBucketOverrides, OtelCollectorOptionsBuilder, OtlpProtocol,
-        PrometheusExporterOptionsBuilder, TaskQueueLabelStrategy, TelemetryOptionsBuilder,
+        HistogramBucketOverrides, OtelCollectorOptions, OtlpProtocol, PrometheusExporterOptions,
+        TaskQueueLabelStrategy, TelemetryOptions,
         metrics::{
             CoreMeter, CounterBase, Gauge, GaugeBase, HistogramBase, MetricKeyValue,
-            MetricParameters, MetricParametersBuilder, NewAttributes,
+            MetricParameters, NewAttributes,
         },
     },
     worker::{
         PollerBehavior, SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerConfigBuilder, WorkerTaskTypes,
-        WorkerVersioningStrategy, WorkflowSlotKind,
+        SlotSupplier, SlotSupplierPermit, WorkerConfig, WorkerTaskTypes, WorkerVersioningStrategy,
+        WorkflowSlotKind,
     },
 };
 use temporalio_sdk::{
@@ -67,7 +67,15 @@ use temporalio_sdk::{
 };
 use temporalio_sdk_core::{
     CoreRuntime, FixedSizeSlotSupplier, TokioRuntimeBuilder, TunerBuilder, init_worker,
-    telemetry::{WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME, build_otlp_metric_exporter},
+    replay::TestHistoryBuilder,
+    telemetry::{
+        WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME, build_otlp_metric_exporter,
+        start_prometheus_metric_exporter,
+    },
+    test_help::{
+        MockPollCfg, ResponseType, TemporalMeter, WorkerExt, WorkerTestHelpers, build_mock_pollers,
+        mock_worker, mock_worker_client,
+    },
 };
 use tokio::{join, sync::Barrier};
 use tonic::IntoRequest;
@@ -83,21 +91,23 @@ async fn prometheus_metrics_exported(
     #[values(true, false)] use_seconds_latency: bool,
     #[values(true, false)] custom_buckets: bool,
 ) {
-    let mut opts_builder = PrometheusExporterOptionsBuilder::default();
-    opts_builder
+    let opts = PrometheusExporterOptions::builder()
         .global_tags(HashMap::from([("global".to_string(), "hi!".to_string())]))
         .socket_addr(ANY_PORT.parse().unwrap())
-        .use_seconds_for_durations(use_seconds_latency);
-    if custom_buckets {
-        opts_builder.histogram_bucket_overrides(HistogramBucketOverrides {
-            overrides: {
-                let mut hm = HashMap::new();
-                hm.insert(REQUEST_LATENCY_HISTOGRAM_NAME.to_string(), vec![1337.0]);
-                hm
-            },
-        });
-    }
-    let (telemopts, addr, _aborter) = prom_metrics(Some(opts_builder.build().unwrap()));
+        .use_seconds_for_durations(use_seconds_latency)
+        .histogram_bucket_overrides(if custom_buckets {
+            HistogramBucketOverrides {
+                overrides: {
+                    let mut hm = HashMap::new();
+                    hm.insert(REQUEST_LATENCY_HISTOGRAM_NAME.to_string(), vec![1337.0]);
+                    hm
+                },
+            }
+        } else {
+            Default::default()
+        })
+        .build();
+    let (telemopts, addr, _aborter) = prom_metrics(Some(opts));
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let opts = get_integ_server_options();
     let mut raw_client = opts
@@ -151,7 +161,7 @@ async fn one_slot_worker_reports_available_slot() {
     let tq = "one_slot_worker_tq";
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
 
-    let worker_cfg = WorkerConfigBuilder::default()
+    let worker_cfg = WorkerConfig::builder()
         .namespace(NAMESPACE)
         .task_queue(tq)
         .versioning_strategy(WorkerVersioningStrategy::None {
@@ -279,6 +289,7 @@ async fn one_slot_worker_reports_available_slot() {
                 "whatever".to_string(),
                 None,
                 WorkflowOptions {
+                    #[allow(deprecated)]
                     id_reuse_policy: WorkflowIdReusePolicy::TerminateIfRunning,
                     execution_timeout: Some(Duration::from_secs(5)),
                     ..Default::default()
@@ -407,7 +418,7 @@ async fn query_of_closed_workflow_doesnt_tick_terminal_metric(
     let mut starter =
         CoreWfStarter::new_with_runtime("query_of_closed_workflow_doesnt_tick_terminal_metric", rt);
     // Disable cache to ensure replay happens completely
-    starter.worker_config.max_cached_workflows(0_usize);
+    starter.worker_config.max_cached_workflows = 0_usize;
     let worker = starter.get_worker().await;
     let run_id = starter.start_wf().await;
     let task = worker.poll_workflow_activation().await.unwrap();
@@ -558,7 +569,7 @@ async fn latency_metrics(
     #[values(true, false)] show_units: bool,
 ) {
     let (telemopts, addr, _aborter) = prom_metrics(Some(
-        PrometheusExporterOptionsBuilder::default()
+        PrometheusExporterOptions::builder()
             .socket_addr(ANY_PORT.parse().unwrap())
             .use_seconds_for_durations(use_seconds_latency)
             .unit_suffix(show_units)
@@ -572,8 +583,7 @@ async fn latency_metrics(
                     hm
                 },
             })
-            .build()
-            .unwrap(),
+            .build(),
     ));
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("latency_metrics", rt);
@@ -663,20 +673,15 @@ async fn request_fail_codes_otel() {
         .ok()
         .map(|x| x.parse::<Url>().unwrap())
     {
-        let opts = OtelCollectorOptionsBuilder::default()
-            .url(url)
-            .build()
-            .unwrap();
+        let opts = OtelCollectorOptions::builder().url(url).build();
         build_otlp_metric_exporter(opts).unwrap()
     } else {
         // skip
         return;
     };
-    let mut telemopts = TelemetryOptionsBuilder::default();
     let exporter = Arc::new(exporter);
-    telemopts.metrics(exporter as Arc<dyn CoreMeter>);
-    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts.build().unwrap()))
-        .unwrap();
+    let telemopts = TelemetryOptions::builder().metrics(exporter as Arc<dyn CoreMeter>);
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts.build())).unwrap();
     let opts = get_integ_server_options();
     let mut client = opts
         .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
@@ -717,18 +722,16 @@ async fn docker_metrics_with_prometheus(
     );
 
     // Configure the OTLP exporter with HTTP
-    let opts = OtelCollectorOptionsBuilder::default()
+    let opts = OtelCollectorOptions::builder()
         .url(otel_collector_addr.parse().unwrap())
         .protocol(otel_protocol)
         .global_tags(HashMap::from([("test_id".to_string(), test_uid.clone())]))
-        .build()
-        .unwrap();
+        .build();
     let exporter = Arc::new(build_otlp_metric_exporter(opts).unwrap());
-    let telemopts = TelemetryOptionsBuilder::default()
+    let telemopts = TelemetryOptions::builder()
         .metrics(exporter as Arc<dyn CoreMeter>)
         .metric_prefix(test_uid.clone())
-        .build()
-        .unwrap();
+        .build();
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let test_name = "docker_metrics_with_prometheus";
     let mut starter = CoreWfStarter::new_with_runtime(test_name, rt);
@@ -786,9 +789,7 @@ async fn activity_metrics() {
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "activity_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter
-        .worker_config
-        .graceful_shutdown_period(Duration::from_secs(1));
+    starter.worker_config.graceful_shutdown_period = Some(Duration::from_secs(1));
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
@@ -920,12 +921,12 @@ async fn nexus_metrics() {
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "nexus_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.worker_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
@@ -1102,9 +1103,7 @@ async fn evict_on_complete_does_not_count_as_forced_eviction() {
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "evict_on_complete_does_not_count_as_forced_eviction";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
 
     worker.register_wf(
@@ -1187,16 +1186,17 @@ async fn metrics_available_from_custom_slot_supplier() {
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter =
         CoreWfStarter::new_with_runtime("metrics_available_from_custom_slot_supplier", rt);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
-    starter.worker_config.clear_max_outstanding_opts();
+    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
+    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;
     let mut tb = TunerBuilder::default();
     tb.workflow_slot_supplier(Arc::new(MetricRecordingSlotSupplier::<WorkflowSlotKind> {
         inner: FixedSizeSlotSupplier::new(5),
         metrics: OnceLock::new(),
     }));
-    starter.worker_config.tuner(Arc::new(tb.build()));
+    starter.worker_config.tuner = Some(Arc::new(tb.build()));
     let mut worker = starter.worker().await;
 
     worker.register_wf(
@@ -1314,17 +1314,11 @@ async fn test_prometheus_metric_format_consistency() {
 
 #[tokio::test]
 async fn prometheus_label_nonsense() {
-    let mut opts_builder = PrometheusExporterOptionsBuilder::default();
-    opts_builder.socket_addr(ANY_PORT.parse().unwrap());
-    let (telemopts, addr, _aborter) = prom_metrics(Some(opts_builder.build().unwrap()));
+    let opts_builder = PrometheusExporterOptions::builder().socket_addr(ANY_PORT.parse().unwrap());
+    let (telemopts, addr, _aborter) = prom_metrics(Some(opts_builder.build()));
     let meter = telemopts.metrics.clone().unwrap();
 
-    let ctr = meter.counter(
-        MetricParametersBuilder::default()
-            .name("some_counter")
-            .build()
-            .unwrap(),
-    );
+    let ctr = meter.counter(MetricParameters::builder().name("some_counter").build());
     let a1 = meter.new_attributes(NewAttributes::from([MetricKeyValue::new("thing", "foo")]));
     let a2 = meter.new_attributes(NewAttributes::from([MetricKeyValue::new("blerp", "baz")]));
     ctr.add(1, &a1);
@@ -1347,20 +1341,17 @@ async fn sticky_queue_label_strategy(
     strategy: TaskQueueLabelStrategy,
 ) {
     let (mut telemopts, addr, _aborter) = prom_metrics(Some(
-        PrometheusExporterOptionsBuilder::default()
+        PrometheusExporterOptions::builder()
             .socket_addr(ANY_PORT.parse().unwrap())
-            .build()
-            .unwrap(),
+            .build(),
     ));
     telemopts.task_queue_label_strategy = strategy;
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = format!("sticky_queue_label_strategy_{strategy:?}");
     let mut starter = CoreWfStarter::new_with_runtime(&wf_name, rt);
     // Enable sticky queues by setting a reasonable cache size
-    starter.worker_config.max_cached_workflows(10_usize);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.worker_config.max_cached_workflows = 10_usize;
+    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
@@ -1436,14 +1427,15 @@ async fn resource_based_tuner_metrics() {
     let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "resource_based_tuner_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
-    starter.worker_config.clear_max_outstanding_opts();
+    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
+    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;
 
     // Create a resource-based tuner with reasonable thresholds
     let tuner = ResourceBasedTuner::new(0.8, 0.8);
-    starter.worker_config.tuner(Arc::new(tuner));
+    starter.worker_config.tuner = Some(Arc::new(tuner));
 
     let mut worker = starter.worker().await;
 
@@ -1487,3 +1479,86 @@ async fn resource_based_tuner_metrics() {
         "CPU PID output metric should be present"
     );
 }
+
+#[tokio::test]
+async fn terminal_metric_not_recorded_on_rejected_completion() {
+    let prom_info = start_prometheus_metric_exporter(
+        PrometheusExporterOptions::builder()
+            .socket_addr(ANY_PORT.parse().unwrap())
+            .build(),
+    )
+    .unwrap();
+    let addr = prom_info.bound_addr;
+    let _abort = prom_info.abort_handle;
+    let meter = TemporalMeter::new(
+        prom_info.meter as Arc<dyn CoreMeter>,
+        NewAttributes { attributes: vec![] },
+        TaskQueueLabelStrategy::UseNormal,
+    );
+
+    // Build a simple workflow history: start + WFT
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(
+        temporalio_common::protos::temporal::api::enums::v1::EventType::WorkflowExecutionStarted,
+    );
+    t.add_workflow_task_scheduled_and_started();
+
+    // First WFT completion is rejected by server, second succeeds
+    let mut call_count = 0;
+    let mut mh = MockPollCfg::from_resp_batches(
+        "fake_wf_id",
+        t,
+        [ResponseType::AllHistory, ResponseType::AllHistory],
+        mock_worker_client(),
+    );
+    mh.completion_mock_fn = Some(Box::new(move |_| {
+        call_count += 1;
+        if call_count == 1 {
+            Err(tonic::Status::not_found("Workflow task not found"))
+        } else {
+            Ok(Default::default())
+        }
+    }));
+
+    let mut mock = build_mock_pollers(mh);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    mock.set_temporal_meter(meter);
+    let core = mock_worker(mock);
+
+    // First attempt: get WFT activation and complete the workflow
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&act.run_id).await;
+
+    // Handle eviction (triggered by NotFound error from server)
+    core.handle_eviction().await;
+
+    // Second attempt (replay after eviction): complete workflow again
+    let act = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&act.run_id).await;
+
+    core.drain_pollers_and_shutdown().await;
+
+    // The workflow_completed metric should be recorded exactly once — only for
+    // the successful server response, not for the rejected first attempt.
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    let matching_line = body.lines().find(|l| l.starts_with("workflow_completed{"));
+    match matching_line {
+        Some(line) => {
+            assert!(
+                line.ends_with(" 1"),
+                "Expected workflow_completed count of 1, got: {line}"
+            );
+            assert!(
+                line.contains("workflow_type=\"default_wf_type\""),
+                "Expected workflow_type label on metric, got: {line}"
+            );
+        }
+        None => panic!(
+            "workflow_completed metric not found. Available metrics:\n{}",
+            body.lines()
+                .filter(|l| l.contains("workflow"))
+                .collect::<Vec<_>>()
+                .join("\n")
+        ),
+    }
+}

package/sdk-core/crates/sdk-core/tests/integ_tests/polling_tests.rs

@@ -29,13 +29,13 @@ use temporalio_common::{
         temporal::api::enums::v1::EventType,
         test_utils::schedule_activity_cmd,
     },
-    telemetry::{Logger, TelemetryOptionsBuilder},
+    telemetry::{Logger, TelemetryOptions},
     worker::PollerBehavior,
 };
 use temporalio_sdk::{ActivityOptions, WfContext};
 use temporalio_sdk_core::{
-    ClientOptions, CoreRuntime, RuntimeOptionsBuilder,
-    ephemeral_server::{TemporalDevServerConfigBuilder, default_cached_download},
+    ClientOptions, CoreRuntime, RuntimeOptions,
+    ephemeral_server::{TemporalDevServerConfig, default_cached_download},
     init_worker,
     telemetry::CoreLogStreamConsumer,
     test_help::{NAMESPACE, WorkerTestHelpers, drain_pollers_and_shutdown},
@@ -125,15 +125,14 @@ async fn out_of_order_completion_doesnt_hang() {
 async fn switching_worker_client_changes_poll() {
     // Start two servers
     info!("Starting servers");
-    let server_config = TemporalDevServerConfigBuilder::default()
+    let server_config = TemporalDevServerConfig::builder()
         .exe(default_cached_download())
         // We need to lower the poll timeout so the poll call rolls over
         .extra_args(vec![
             "--dynamic-config-value".to_string(),
             "matching.longPollExpirationInterval=\"1s\"".to_string(),
         ])
-        .build()
-        .unwrap();
+        .build();
     let mut server1 = server_config
         .start_server_with_output(Stdio::null(), Stdio::null())
         .await
@@ -191,16 +190,10 @@ async fn switching_worker_client_changes_poll() {
             .unwrap();
 
         // Create a worker only on the first server
-        let worker = init_worker(
-            init_integ_telem().unwrap(),
-            integ_worker_config("my-task-queue")
-                // We want a cache so we don't get extra remove-job activations
-                .max_cached_workflows(100_usize)
-                .build()
-                .unwrap(),
-            client1.clone(),
-        )
-        .unwrap();
+        let mut config = integ_worker_config("my-task-queue");
+        // We want a cache so we don't get extra remove-job activations
+        config.max_cached_workflows = 100_usize;
+        let worker = init_worker(init_integ_telem().unwrap(), config, client1.clone()).unwrap();
 
         // Poll for first task, confirm it's first wf, complete, and wait for complete
         info!("Doing initial poll");
@@ -252,24 +245,18 @@ async fn small_workflow_slots_and_pollers(#[values(false, true)] use_autoscaling
     let wf_name = "only_one_workflow_slot_and_two_pollers";
     let mut starter = CoreWfStarter::new(wf_name);
     if use_autoscaling {
-        starter
-            .worker_config
-            .workflow_task_poller_behavior(PollerBehavior::Autoscaling {
-                minimum: 1,
-                maximum: 5,
-                initial: 1,
-            });
+        starter.worker_config.workflow_task_poller_behavior = PollerBehavior::Autoscaling {
+            minimum: 1,
+            maximum: 5,
+            initial: 1,
+        };
     } else {
-        starter
-            .worker_config
-            .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2));
+        starter.worker_config.workflow_task_poller_behavior = PollerBehavior::SimpleMaximum(2);
     }
-    starter
-        .worker_config
-        .max_outstanding_workflow_tasks(2_usize)
-        .max_outstanding_local_activities(1_usize)
-        .activity_task_poller_behavior(PollerBehavior::SimpleMaximum(1))
-        .max_outstanding_activities(1_usize);
+    starter.worker_config.max_outstanding_workflow_tasks = Some(2_usize);
+    starter.worker_config.max_outstanding_local_activities = Some(1_usize);
+    starter.worker_config.activity_task_poller_behavior = PollerBehavior::SimpleMaximum(1);
+    starter.worker_config.max_outstanding_activities = Some(1_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         for _ in 0..3 {
@@ -330,14 +317,13 @@ async fn small_workflow_slots_and_pollers(#[values(false, true)] use_autoscaling
 #[tokio::test]
 async fn replace_client_works_after_polling_failure() {
     let (log_consumer, mut log_rx) = CoreLogStreamConsumer::new(100);
-    let telem_opts = TelemetryOptionsBuilder::default()
+    let telem_opts = TelemetryOptions::builder()
         .logging(Logger::Push {
             filter: "OFF,temporalio_client=DEBUG".into(),
             consumer: Arc::new(log_consumer),
         })
-        .build()
-        .unwrap();
-    let runtime_opts = RuntimeOptionsBuilder::default()
+        .build();
+    let runtime_opts = RuntimeOptions::builder()
         .telemetry_options(telem_opts)
         .build()
         .unwrap();
@@ -376,7 +362,7 @@ async fn replace_client_works_after_polling_failure() {
 
     // Starting a second dev server for the worker to connect to initially. Later this server will be shut down
     // and the worker client replaced with a client connected to the main integration test server.
-    let initial_server_config = integ_dev_server_config(vec![]).build().unwrap();
+    let initial_server_config = integ_dev_server_config(vec![], false);
     let initial_server = Arc::new(Mutex::new(Some(
         initial_server_config
             .start_server_with_output(Stdio::null(), Stdio::null())
@@ -405,17 +391,10 @@ async fn replace_client_works_after_polling_failure() {
             let wf_name = "replace_client_works_after_polling_failure";
             let task_queue = format!("{wf_name}_tq");
 
-            let worker = Arc::new(
-                init_worker(
-                    &rt,
-                    integ_worker_config(&task_queue)
-                        .max_cached_workflows(100_usize)
-                        .build()
-                        .unwrap(),
-                    client_for_initial_server.clone(),
-                )
-                .unwrap(),
-            );
+            let mut config = integ_worker_config(&task_queue);
+            config.max_cached_workflows = 100_usize;
+            let worker =
+                Arc::new(init_worker(&rt, config, client_for_initial_server.clone()).unwrap());
 
             // Polling the initial server the first time is successful.
             let wf_1 = client_for_initial_server