@temporalio/core-bridge 0.22.0 → 1.0.0-rc.1

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

@@ -6,9 +6,12 @@ use temporal_sdk::{
     interceptors::WorkerInterceptor, ActContext, ActivityCancelledError, CancellableFuture,
     LocalActivityOptions, WfContext, WorkflowResult,
 };
-use temporal_sdk_core_protos::coresdk::{
-    common::RetryPolicy, workflow_commands::ActivityCancellationType,
-    workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_commands::ActivityCancellationType,
+        workflow_completion::WorkflowActivationCompletion, AsJsonPayloadExt,
+    },
+    temporal::api::common::v1::RetryPolicy,
 };
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio_util::sync::CancellationToken;
@@ -494,12 +497,15 @@ async fn schedule_to_close_timeout_across_timer_backoff(#[case] cached: bool) {
     worker.run_until_done().await.unwrap();
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn eviction_wont_make_local_act_get_dropped() {
-    let wf_name = "eviction_wont_make_local_act_get_dropped";
-    let mut starter = CoreWfStarter::new(wf_name);
+async fn eviction_wont_make_local_act_get_dropped(#[values(true, false)] short_wft_timeout: bool) {
+    let wf_name = format!(
+        "eviction_wont_make_local_act_get_dropped_{}",
+        short_wft_timeout
+    );
+    let mut starter = CoreWfStarter::new(&wf_name);
     starter.max_cached_workflows(0);
-    starter.wft_timeout(Duration::from_secs(1));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), local_act_then_timer_then_wait);
     worker.register_activity("echo_activity", |_ctx: ActContext, str: String| async {
@@ -507,13 +513,16 @@ async fn eviction_wont_make_local_act_get_dropped() {
         Ok(str)
     });
 
+    let opts = if short_wft_timeout {
+        WorkflowOptions {
+            task_timeout: Some(Duration::from_secs(1)),
+            ..Default::default()
+        }
+    } else {
+        Default::default()
+    };
     worker
-        .submit_wf(
-            wf_name.to_owned(),
-            wf_name.to_owned(),
-            vec![],
-            WorkflowOptions::default(),
-        )
+        .submit_wf(wf_name.to_owned(), wf_name.to_owned(), vec![], opts)
         .await
         .unwrap();
     worker.run_until_done().await.unwrap();
@@ -571,3 +580,55 @@ async fn timer_backoff_concurrent_with_non_timer_backoff() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+#[tokio::test]
+async fn repro_nondeterminism_with_timer_bug() {
+    let wf_name = "repro_nondeterminism_with_timer_bug";
+    let mut starter = CoreWfStarter::new(wf_name);
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let t1 = ctx.timer(Duration::from_secs(30));
+        let r1 = ctx.local_activity(LocalActivityOptions {
+            activity_type: "delay".to_string(),
+            input: "hi".as_json_payload().expect("serializes fine"),
+            retry_policy: RetryPolicy {
+                initial_interval: Some(Duration::from_micros(15).into()),
+                backoff_coefficient: 1_000.,
+                maximum_interval: Some(Duration::from_millis(1500).into()),
+                maximum_attempts: 4,
+                non_retryable_error_types: vec![],
+            },
+            timer_backoff_threshold: Some(Duration::from_secs(1)),
+            ..Default::default()
+        });
+        tokio::pin!(t1);
+        tokio::select! {
+            _ = &mut t1 => {},
+            _ = r1 => {
+                t1.cancel(&ctx);
+            },
+        };
+        ctx.timer(Duration::from_secs(1)).await;
+        Ok(().into())
+    });
+    worker.register_activity("delay", |_: ActContext, _: String| async {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        Ok(())
+    });
+
+    let run_id = worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+    starter
+        .fetch_history_and_replay(wf_name, run_id, worker.inner_mut())
+        .await
+        .unwrap();
+}

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

@@ -112,6 +112,25 @@ async fn replay_using_wf_function() {
     worker.run().await.unwrap();
 }
 
+#[tokio::test]
+async fn replay_ok_ending_with_terminated_or_timed_out() {
+    let mut t1 = canned_histories::single_timer("1");
+    t1.add_workflow_execution_terminated();
+    let mut t2 = canned_histories::single_timer("1");
+    t2.add_workflow_execution_timed_out();
+    telemetry_init(&get_integ_telem_options()).unwrap();
+    for t in [t1, t2] {
+        let func = timers_wf(1);
+        let (worker, _) = init_core_replay_preloaded(
+            "replay_ok_terminate",
+            &t.get_full_history_info().unwrap().into(),
+        );
+        let mut worker = Worker::new_from_core(worker, "replay_ok_terminate".to_string());
+        worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+        worker.run().await.unwrap();
+    }
+}
+
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
     WorkflowFunction::new(move |ctx: WfContext| async move {
         for _ in 1..=num_timers {

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

@@ -15,7 +15,7 @@ async fn reset_workflow() {
     let wf_name = "reset_me_wf";
     let mut starter = CoreWfStarter::new(wf_name);
     let mut worker = starter.worker().await;
-    worker.auto_shutdown = false;
+    worker.fetch_results = false;
     let notify = Arc::new(Notify::new());
 
     let wf_notify = notify.clone();

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

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
@@ -61,6 +61,9 @@ async fn sends_upsert() {
             payload.metadata.get("encoding").unwrap()
         );
     }
-    assert_eq!("\"goodbye\"", txt_attr_payload.to_string());
-    assert_eq!("98", int_attr_payload.to_string());
+    assert_eq!(
+        "goodbye",
+        String::from_json_payload(txt_attr_payload).unwrap()
+    );
+    assert_eq!(98, usize::from_json_payload(int_attr_payload).unwrap());
 }

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

@@ -1,4 +1,5 @@
 mod activities;
+mod appdata_propagation;
 mod cancel_external;
 mod cancel_wf;
 mod child_workflows;
@@ -420,7 +421,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let mut wf_starter = CoreWfStarter::new("wft_timeout_doesnt_create_unsolvable_autocomplete");
     wf_starter
         // Test needs eviction on and a short timeout
-        .max_cached_workflows(0usize)
+        .max_cached_workflows(0)
+        .max_wft(1)
         .wft_timeout(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;
@@ -445,26 +447,6 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .unwrap();
         wf_task
     };
-    let poll_sched_act_poll = || async {
-        poll_sched_act().await;
-        let wf_task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            wf_task.jobs.as_slice(),
-            [
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::ResolveActivity(_)),
-                },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                }
-            ]
-        );
-        wf_task
-    };
-
     wf_starter.start_wf().await;
 
     // Poll and schedule the activity
@@ -503,7 +485,8 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .await
         .unwrap();
     // Start from the beginning
-    let wf_task = poll_sched_act_poll().await;
+    poll_sched_act().await;
+    let wf_task = core.poll_workflow_activation().await.unwrap();
     // Time out this time
     sleep(Duration::from_secs(2)).await;
     // Poll again, which should not have any work to do and spin, until the complete goes through.
@@ -526,7 +509,11 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         .await
         .unwrap();
     // Do it all over again, without timing out this time
-    let wf_task = poll_sched_act_poll().await;
+    poll_sched_act().await;
+    let wf_task = core.poll_workflow_activation().await.unwrap();
+    // Server can sometimes arbitrarily re-order the activity complete to be after the second signal
+    // Seeing 3 jobs is enough info.
+    assert_eq!(wf_task.jobs.len(), 3);
     core.complete_execution(&wf_task.run_id).await;
 }
 

package/sdk-core/tests/load_tests.rs

@@ -113,6 +113,7 @@ async fn activity_load() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn workflow_load() {
     const SIGNAME: &str = "signame";
+    let num_workflows = 200;
     let wf_name = "workflow_load";
     let mut starter = CoreWfStarter::new("workflow_load");
     starter
@@ -151,7 +152,7 @@ async fn workflow_load() {
     let client = starter.get_client().await;
 
     let mut workflow_handles = vec![];
-    for i in 0..200 {
+    for i in 0..num_workflows {
         let wfid = format!("{}_{}", wf_name, i);
         let rid = worker
             .submit_wf(
@@ -167,7 +168,7 @@ async fn workflow_load() {
 
     let sig_sender = async {
         loop {
-            let sends: FuturesUnordered<_> = (0..200)
+            let sends: FuturesUnordered<_> = (0..num_workflows)
                 .map(|i| {
                     client.signal_workflow_execution(
                         format!("{}_{}", wf_name, i),
@@ -177,7 +178,11 @@ async fn workflow_load() {
                     )
                 })
                 .collect();
-            sends.map(|_| Ok(())).forward(sink::drain()).await.unwrap();
+            sends
+                .map(|_| Ok(()))
+                .forward(sink::drain())
+                .await
+                .expect("Sending signals works");
             tokio::time::sleep(Duration::from_secs(2)).await;
         }
     };

package/sdk-core/tests/main.rs

@@ -28,7 +28,7 @@ mod integ_tests {
         let opts = get_integ_server_options();
         let telem_d = telemetry_init(&get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(telem_d.get_metric_meter())
+            .connect_no_namespace(telem_d.get_metric_meter(), None)
             .await
             .unwrap();
 
@@ -73,7 +73,8 @@ mod integ_tests {
         .unwrap();
         let sgo = ClientOptionsBuilder::default()
             .target_url(Url::from_str("https://localhost:7233").unwrap())
-            .worker_binary_id("binident".to_string())
+            .client_name("tls_tester")
+            .client_version("clientver")
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
                 domain: Some("tls-sample".to_string()),
@@ -84,7 +85,10 @@ mod integ_tests {
             })
             .build()
             .unwrap();
-        let con = sgo.connect(NAMESPACE.to_string(), None).await.unwrap();
+        let con = sgo
+            .connect(NAMESPACE.to_string(), None, None)
+            .await
+            .unwrap();
         con.list_namespaces().await.unwrap();
     }
 }

package/src/conversions.rs

@@ -1,48 +1,48 @@
 use log::LevelFilter;
+use neon::types::buffer::TypedArray;
 use neon::{
     context::Context,
     handle::Handle,
     prelude::*,
-    types::{JsNumber, JsString},
+    types::{JsBoolean, JsNumber, JsString},
 };
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
-use std::{fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
+use std::{collections::HashMap, fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
     api::worker::{WorkerConfig, WorkerConfigBuilder},
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TelemetryOptions,
-    TelemetryOptionsBuilder, TlsConfig, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricsExporter,
+    OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder, TlsConfig,
+    TraceExporter, Url,
 };
 
-macro_rules! js_value_getter {
-    ($js_cx:expr, $js_obj:ident, $prop_name:expr, $js_type:ty) => {
-        $js_obj
-            .get($js_cx, $prop_name)?
-            .downcast::<$js_type, _>($js_cx)
-            .map_err(|_| {
-                $js_cx
-                    .throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", $prop_name))
-                    .unwrap_err()
-            })?
-            .value($js_cx)
-    };
-}
-
+#[macro_export]
 macro_rules! js_optional_getter {
     ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
         match get_optional($js_cx, $js_obj, $prop_name) {
-            Some(val) => Some(val.downcast::<$js_type, _>($js_cx).map_err(|_| {
-                $js_cx
-                    .throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", $prop_name))
-                    .unwrap_err()
-            })?),
             None => None,
+            Some(val) => {
+                if val.is_a::<$js_type, _>($js_cx) {
+                    Some(val.downcast_or_throw::<$js_type, _>($js_cx)?)
+                } else {
+                    Some($js_cx.throw_type_error(format!("Invalid {}", $prop_name))?)
+                }
+            }
+        }
+    };
+}
+
+macro_rules! js_value_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        match js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type) {
+            Some(val) => val.value($js_cx),
+            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
         }
     };
 }
 
 /// Helper for extracting an optional attribute from [obj].
 /// If [obj].[attr] is undefined or not present, None is returned
-fn get_optional<'a, C, K>(
+pub fn get_optional<'a, C, K>(
     cx: &mut C,
     obj: &Handle<JsObject>,
     attr: K,
@@ -51,7 +51,7 @@ where
     K: neon::object::PropertyKey,
     C: Context<'a>,
 {
-    match obj.get(cx, attr) {
+    match obj.get_value(cx, attr) {
         Err(_) => None,
         Ok(val) => match val.is_a::<JsUndefined, _>(cx) {
             true => None,
@@ -75,7 +75,7 @@ where
             cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
                 .unwrap_err()
         })?;
-        Ok(Some(cx.borrow(&buf, |data| data.as_slice::<u8>().to_vec())))
+        Ok(Some(buf.as_slice(cx).to_vec()))
     } else {
         Ok(None)
     }
@@ -97,7 +97,7 @@ where
             cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
                 .unwrap_err()
         })?;
-        Ok(cx.borrow(&buf, |data| data.as_slice::<u8>().to_vec()))
+        Ok(buf.as_slice(cx).to_vec())
     } else {
         cx.throw_type_error::<_, Vec<u8>>(format!("Invalid or missing {}", full_attr_path))
     }
@@ -108,6 +108,10 @@ pub(crate) trait ObjectHandleConversionsExt {
     fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions>;
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig>;
+    fn as_hash_map_of_string_to_string(
+        &self,
+        cx: &mut FunctionContext,
+    ) -> NeonResult<HashMap<String, String>>;
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
@@ -124,6 +128,22 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         ))
     }
 
+    fn as_hash_map_of_string_to_string(
+        &self,
+        cx: &mut FunctionContext,
+    ) -> NeonResult<HashMap<String, String>> {
+        let props = self.get_own_property_names(cx)?;
+        let props = props.to_vec(cx)?;
+        let mut map = HashMap::new();
+        for k in props {
+            let k = k.to_string(cx)?;
+            let v = self.get::<JsString, _, _>(cx, k)?.value(cx);
+            let k = k.value(cx);
+            map.insert(k, v);
+        }
+        Ok(map)
+    }
+
     fn as_client_options(&self, cx: &mut FunctionContext) -> NeonResult<ClientOptions> {
         let url = match Url::parse(&js_value_getter!(cx, self, "url", JsString)) {
             Ok(url) => url,
@@ -167,7 +187,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
         let retry_config = match js_optional_getter!(cx, self, "retry", JsObject) {
             None => RetryConfig::default(),
-            Some(retry_config) => RetryConfig {
+            Some(ref retry_config) => RetryConfig {
                 initial_interval: Duration::from_millis(js_value_getter!(
                     cx,
                     retry_config,
@@ -198,68 +218,119 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             },
         };
 
-        let mut gateway_opts = ClientOptionsBuilder::default();
+        let mut client_options = ClientOptionsBuilder::default();
         if let Some(tls_cfg) = tls_cfg {
-            gateway_opts.tls_cfg(tls_cfg);
+            client_options.tls_cfg(tls_cfg);
         }
-        Ok(gateway_opts
+
+        Ok(client_options
             .client_name("temporal-typescript".to_string())
             .client_version(js_value_getter!(cx, self, "sdkVersion", JsString))
             .target_url(url)
-            .identity(js_value_getter!(cx, self, "identity", JsString))
-            .worker_binary_id(js_value_getter!(cx, self, "workerBinaryId", JsString))
             .retry_config(retry_config)
             .build()
             .expect("Core server gateway options must be valid"))
     }
 
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
-        let log_forwarding_level_str =
-            js_value_getter!(cx, self, "logForwardingLevel", JsString).replace("WARNING", "WARN");
-        let log_forwarding_level =
-            LevelFilter::from_str(&log_forwarding_level_str).unwrap_or(LevelFilter::Off);
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        if let Some(url) = js_optional_getter!(cx, self, "oTelCollectorUrl", JsString) {
-            let url = match Url::parse(&url.value(cx)) {
-                Ok(url) => url,
-                Err(_) => cx.throw_type_error("Invalid telemetryOptions.oTelCollectorUrl")?,
-            };
-            telemetry_opts.otel_collector_url(url);
+
+        if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
+            telemetry_opts.tracing_filter(tf.value(cx));
         }
-        if let Some(addr) = js_optional_getter!(cx, self, "prometheusMetricsBindAddress", JsString)
-        {
-            match addr.value(cx).parse::<SocketAddr>() {
-                Ok(address) => telemetry_opts.prometheus_export_bind_address(address),
-                Err(_) => {
-                    cx.throw_type_error("Invalid telemetryOptions.prometheusMetricsBindAddress")?
+        telemetry_opts.no_temporal_prefix_for_metrics(
+            js_optional_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
+                .map(|b| b.value(cx))
+                .unwrap_or_default(),
+        );
+        if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
+            if let Some(_) = get_optional(cx, logging, "console") {
+                telemetry_opts.logging(Logger::Console);
+            } else if let Some(ref forward) = js_optional_getter!(cx, logging, "forward", JsObject)
+            {
+                let level = js_value_getter!(cx, forward, "level", JsString);
+                match LevelFilter::from_str(&level) {
+                    Ok(level) => {
+                        telemetry_opts.logging(Logger::Forward(level));
+                    }
+                    Err(err) => cx.throw_type_error(format!(
+                        "Invalid telemetryOptions.logging.forward.level: {}",
+                        err
+                    ))?,
                 }
-            };
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.logging, missing `console` or `forward` option"
+                ))?
+            }
         }
-        if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
-            telemetry_opts.tracing_filter(tf.value(cx));
+        if let Some(metrics) = js_optional_getter!(cx, self, "metrics", JsObject) {
+            if let Some(ref prom) = js_optional_getter!(cx, &metrics, "prometheus", JsObject) {
+                let addr = js_value_getter!(cx, prom, "bindAddress", JsString);
+                match addr.parse::<SocketAddr>() {
+                    Ok(address) => telemetry_opts.metrics(MetricsExporter::Prometheus(address)),
+                    Err(_) => cx.throw_type_error(
+                        "Invalid telemetryOptions.metrics.prometheus.bindAddress",
+                    )?,
+                };
+            } else if let Some(ref otel) = js_optional_getter!(cx, &metrics, "otel", JsObject) {
+                let url = js_value_getter!(cx, otel, "url", JsString);
+                let url = match Url::parse(&url) {
+                    Ok(url) => url,
+                    Err(_) => cx.throw_type_error("Invalid telemetryOptions.metrics.otel.url")?,
+                };
+                let headers =
+                    if let Some(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                        headers.as_hash_map_of_string_to_string(cx)?
+                    } else {
+                        Default::default()
+                    };
+                telemetry_opts
+                    .metrics(MetricsExporter::Otel(OtelCollectorOptions { url, headers }));
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option"
+                ))?
+            }
         }
-        telemetry_opts
-            .log_forwarding_level(log_forwarding_level)
-            .build()
-            .map_err(|reason| {
-                cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
-                    .unwrap_err()
-            })
+
+        if let Some(tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
+            if let Some(ref otel) = js_optional_getter!(cx, &tracing, "otel", JsObject) {
+                let url = js_value_getter!(cx, otel, "url", JsString);
+                let url = match Url::parse(&url) {
+                    Ok(url) => url,
+                    Err(_) => cx.throw_type_error("Invalid telemetryOptions.tracing.otel.url")?,
+                };
+                let headers =
+                    if let Some(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                        headers.as_hash_map_of_string_to_string(cx)?
+                    } else {
+                        Default::default()
+                    };
+                telemetry_opts.tracing(TraceExporter::Otel(OtelCollectorOptions { url, headers }));
+            } else {
+                cx.throw_type_error(format!(
+                    "Invalid telemetryOptions.tracing, missing `otel` option"
+                ))?
+            }
+        }
+        telemetry_opts.build().map_err(|reason| {
+            cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
+                .unwrap_err()
+        })
     }
 
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig> {
         let namespace = js_value_getter!(cx, self, "namespace", JsString);
         let task_queue = js_value_getter!(cx, self, "taskQueue", JsString);
+        let enable_remote_activities =
+            js_value_getter!(cx, self, "enableNonLocalActivities", JsBoolean);
         let max_outstanding_activities =
             js_value_getter!(cx, self, "maxConcurrentActivityTaskExecutions", JsNumber) as usize;
+        let max_outstanding_local_activities =
+            js_value_getter!(cx, self, "maxConcurrentLocalActivityExecutions", JsNumber) as usize;
         let max_outstanding_workflow_tasks =
             js_value_getter!(cx, self, "maxConcurrentWorkflowTaskExecutions", JsNumber) as usize;
-        let max_concurrent_wft_polls =
-            js_value_getter!(cx, self, "maxConcurrentWorkflowTaskPolls", JsNumber) as usize;
-        let max_concurrent_at_polls =
-            js_value_getter!(cx, self, "maxConcurrentActivityTaskPolls", JsNumber) as usize;
-        let nonsticky_to_sticky_poll_ratio =
-            js_value_getter!(cx, self, "nonStickyToStickyPollRatio", JsNumber) as f32;
         let sticky_queue_schedule_to_start_timeout = Duration::from_millis(js_value_getter!(
             cx,
             self,
@@ -283,20 +354,28 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             JsNumber
         ) as u64);
 
+        let max_worker_activities_per_second =
+            js_optional_getter!(cx, self, "maxActivitiesPerSecond", JsNumber)
+                .map(|num| num.value(cx) as f64);
+        let max_task_queue_activities_per_second =
+            js_optional_getter!(cx, self, "maxTaskQueueActivitiesPerSecond", JsNumber)
+                .map(|num| num.value(cx) as f64);
+
         match WorkerConfigBuilder::default()
-            .no_remote_activities(false) // TODO: make this configurable once Core implements local activities
-            .max_concurrent_at_polls(max_concurrent_at_polls)
-            .max_concurrent_wft_polls(max_concurrent_wft_polls)
+            .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
+            .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
+            .no_remote_activities(!enable_remote_activities)
             .max_outstanding_workflow_tasks(max_outstanding_workflow_tasks)
             .max_outstanding_activities(max_outstanding_activities)
+            .max_outstanding_local_activities(max_outstanding_local_activities)
             .max_cached_workflows(max_cached_workflows)
-            .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
             .namespace(namespace)
             .task_queue(task_queue)
             .max_heartbeat_throttle_interval(max_heartbeat_throttle_interval)
             .default_heartbeat_throttle_interval(default_heartbeat_throttle_interval)
-            .max_outstanding_local_activities(10_usize) // TODO: Pass in
+            .max_worker_activities_per_second(max_worker_activities_per_second)
+            .max_task_queue_activities_per_second(max_task_queue_activities_per_second)
             .build()
         {
             Ok(worker_cfg) => Ok(worker_cfg),