@temporalio/core-bridge 1.8.5 → 1.9.0-rc.0

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

@@ -2,7 +2,10 @@ use crate::integ_tests::activity_functions::echo;
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use futures_util::future::join_all;
-use std::time::Duration;
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
 use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
 use temporal_sdk::{
     ActContext, ActExitValue, ActivityCancelledError, ActivityOptions, CancellableFuture,
@@ -974,3 +977,43 @@ async fn graceful_shutdown() {
     };
     join!(shutdowner, runner);
 }
+
+#[tokio::test]
+async fn activity_can_be_cancelled_by_local_timeout() {
+    let wf_name = "activity_can_be_cancelled_by_local_timeout";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter
+        .worker_config
+        .local_timeout_buffer_for_activities(Duration::from_secs(0));
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
+        let res = ctx
+            .activity(ActivityOptions {
+                activity_type: "echo_activity".to_string(),
+                start_to_close_timeout: Some(Duration::from_secs(1)),
+                input: "hi!".as_json_payload().expect("serializes fine"),
+                retry_policy: Some(RetryPolicy {
+                    maximum_attempts: 1,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            })
+            .await;
+        assert!(res.timed_out().is_some());
+        Ok(().into())
+    });
+    static WAS_CANCELLED: AtomicBool = AtomicBool::new(false);
+    worker.register_activity(
+        "echo_activity",
+        |ctx: ActContext, echo_me: String| async move {
+            // Doesn't heartbeat
+            ctx.cancelled().await;
+            WAS_CANCELLED.store(true, Ordering::Relaxed);
+            Ok(echo_me)
+        },
+    );
+
+    starter.start_with_worker(wf_name, &mut worker).await;
+    worker.run_until_done().await.unwrap();
+    assert!(WAS_CANCELLED.load(Ordering::Relaxed));
+}

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

@@ -25,7 +25,7 @@ async fn cancel_sender(ctx: WfContext) -> WorkflowResult<()> {
     Ok(().into())
 }
 
-async fn cancel_receiver(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn cancel_receiver(ctx: WfContext) -> WorkflowResult<()> {
     ctx.cancelled().await;
     Ok(().into())
 }

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

@@ -4,7 +4,7 @@ use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
 use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowExecutionStatus;
 use temporal_sdk_core_test_utils::CoreWfStarter;
 
-async fn cancelled_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+async fn cancelled_wf(ctx: WfContext) -> WorkflowResult<()> {
     let cancelled = tokio::select! {
         _ = ctx.timer(Duration::from_secs(500)) => false,
         _ = ctx.cancelled() => true

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

@@ -64,7 +64,7 @@ async fn abandoned_child_bug_repro() {
 
     worker.register_wf(
         PARENT_WF_TYPE.to_string(),
-        move |mut ctx: WfContext| async move {
+        move |ctx: WfContext| async move {
             let child = ctx.child_workflow(ChildWorkflowOptions {
                 workflow_id: "abandoned-child".to_owned(),
                 workflow_type: CHILD_WF_TYPE.to_owned(),
@@ -89,7 +89,7 @@ async fn abandoned_child_bug_repro() {
             Ok(().into())
         },
     );
-    worker.register_wf(CHILD_WF_TYPE.to_string(), |mut ctx: WfContext| async move {
+    worker.register_wf(CHILD_WF_TYPE.to_string(), |ctx: WfContext| async move {
         ctx.cancelled().await;
         Ok(WfExitValue::<()>::Cancelled)
     });
@@ -135,9 +135,9 @@ async fn abandoned_child_resolves_post_cancel() {
 
     worker.register_wf(
         PARENT_WF_TYPE.to_string(),
-        move |mut ctx: WfContext| async move {
+        move |ctx: WfContext| async move {
             let child = ctx.child_workflow(ChildWorkflowOptions {
-                workflow_id: "abandoned-child".to_owned(),
+                workflow_id: "abandoned-child-resolve-post-cancel".to_owned(),
                 workflow_type: CHILD_WF_TYPE.to_owned(),
                 parent_close_policy: ParentClosePolicy::Abandon,
                 cancel_type: ChildWorkflowCancellationType::Abandon,

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

@@ -0,0 +1,61 @@
+use std::time::Duration;
+use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo};
+use temporal_sdk::{WfContext, WorkflowResult};
+use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
+
+pub async fn eager_wf(_context: WfContext) -> WorkflowResult<()> {
+    Ok(().into())
+}
+
+#[tokio::test]
+async fn eager_wf_start() {
+    let wf_name = "eager_wf_start";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.workflow_options.enable_eager_workflow_start = true;
+    // hang the test if eager task dispatch failed
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), eager_wf);
+    starter.eager_start_with_worker(wf_name, &mut worker).await;
+    worker.run_until_done().await.unwrap();
+}
+
+#[tokio::test]
+async fn eager_wf_start_different_clients() {
+    let wf_name = "eager_wf_start";
+    let mut starter = CoreWfStarter::new(wf_name);
+    starter.workflow_options.enable_eager_workflow_start = true;
+    // hang the test if wf task needs retry
+    starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
+    starter.no_remote_activities();
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), eager_wf);
+
+    let client = get_integ_server_options()
+        .connect(NAMESPACE.to_string(), None, None)
+        .await
+        .expect("Should connect");
+    let w = starter.get_worker().await;
+    let res = client
+        .start_workflow(
+            vec![],
+            w.get_config().task_queue.clone(), // task_queue
+            wf_name.to_string(),               // workflow_id
+            wf_name.to_string(),               // workflow_type
+            None,
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
+    // different clients means no eager_wf_start.
+    assert!(res.eager_workflow_task.is_none());
+
+    //wf task delivered through default path
+    worker.started_workflows.lock().push(WorkflowExecutionInfo {
+        namespace: NAMESPACE.to_string(),
+        workflow_id: wf_name.to_string(),
+        run_id: Some(res.run_id.clone()),
+    });
+    worker.run_until_done().await.unwrap();
+}

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

@@ -167,6 +167,19 @@ async fn replay_ok_ending_with_timed_out() {
     replay_abrupt_ending(t2).await;
 }
 
+#[tokio::test]
+async fn replay_shutdown_worker() {
+    let t = canned_histories::single_timer("1");
+    let func = timers_wf(1);
+    let mut worker = replay_sdk_worker([test_hist_to_replay(t)]);
+    worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+    let shutdown_ctr_i = UniqueShutdownWorker::default();
+    let shutdown_ctr = shutdown_ctr_i.runs.clone();
+    worker.set_worker_interceptor(shutdown_ctr_i);
+    worker.run().await.unwrap();
+    assert_eq!(shutdown_ctr.lock().len(), 1);
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn multiple_histories_replay(#[values(false, true)] use_feeder: bool) {
@@ -188,7 +201,7 @@ async fn multiple_histories_replay(#[values(false, true)] use_feeder: bool) {
     };
     let runs_ctr_i = UniqueRunsCounter::default();
     let runs_ctr = runs_ctr_i.runs.clone();
-    worker.set_worker_interceptor(Box::new(runs_ctr_i));
+    worker.set_worker_interceptor(runs_ctr_i);
     worker.register_wf("onetimer", one_timer_wf);
     worker.register_wf("seqtimer", seq_timer_wf);
 
@@ -287,6 +300,18 @@ impl WorkerInterceptor for UniqueRunsCounter {
     async fn on_workflow_activation_completion(&self, completion: &WorkflowActivationCompletion) {
         self.runs.lock().insert(completion.run_id.clone());
     }
+}
 
-    fn on_shutdown(&self, _: &Worker) {}
+#[derive(Default)]
+struct UniqueShutdownWorker {
+    runs: Arc<Mutex<HashSet<String>>>,
+}
+#[async_trait::async_trait(?Send)]
+impl WorkerInterceptor for UniqueShutdownWorker {
+    fn on_shutdown(&self, _sdk_worker: &Worker) {
+        // Assumed one worker per task queue.
+        self.runs
+            .lock()
+            .insert(_sdk_worker.task_queue().to_string());
+    }
 }

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

@@ -5,6 +5,7 @@ mod cancel_wf;
 mod child_workflows;
 mod continue_as_new;
 mod determinism;
+mod eager;
 mod local_activities;
 mod modify_wf_properties;
 mod patches;

package/sdk-core/tests/main.rs

@@ -14,6 +14,7 @@ mod integ_tests {
     mod metrics_tests;
     mod polling_tests;
     mod queries_tests;
+    mod update_tests;
     mod visibility_tests;
     mod workflow_tests;
 
@@ -37,7 +38,7 @@ mod integ_tests {
         let opts = get_integ_server_options();
         let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(runtime.metric_meter().as_deref(), None)
+            .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter(), None)
             .await
             .unwrap();
 

package/sdk-core/tests/runner.rs

@@ -70,10 +70,19 @@ async fn main() -> Result<(), anyhow::Error> {
         ServerKind::TemporalCLI => {
             let config = TemporalDevServerConfigBuilder::default()
                 .exe(default_cached_download())
+                // TODO: Delete when temporalCLI enables it by default.
+                .extra_args(vec![
+                    "--dynamic-config-value".to_string(),
+                    "system.enableEagerWorkflowStart=true".to_string(),
+                ])
                 .build()?;
             println!("Using temporal CLI");
             (
-                Some(config.start_server_with_output(Stdio::null()).await?),
+                Some(
+                    config
+                        .start_server_with_output(Stdio::null(), Stdio::null())
+                        .await?,
+                ),
                 vec![(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR, "true")],
             )
         }
@@ -83,7 +92,11 @@ async fn main() -> Result<(), anyhow::Error> {
                 .build()?;
             println!("Using java test server");
             (
-                Some(config.start_server_with_output(Stdio::null()).await?),
+                Some(
+                    config
+                        .start_server_with_output(Stdio::null(), Stdio::null())
+                        .await?,
+                ),
                 vec![(INTEG_TEST_SERVER_USED_ENV_VAR, "true")],
             )
         }

package/src/conversions.rs

@@ -5,18 +5,20 @@ use neon::{
     prelude::*,
     types::{JsBoolean, JsNumber, JsString},
 };
-use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
-use std::{collections::HashMap, net::SocketAddr, str::FromStr, time::Duration};
+use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 use temporal_sdk_core::{
-    api::telemetry::{
-        Logger, MetricTemporality, MetricsExporter, OtelCollectorOptions, TelemetryOptions,
-        TelemetryOptionsBuilder, TraceExportConfig, TraceExporter,
+    api::telemetry::{Logger, MetricTemporality, TelemetryOptions, TelemetryOptionsBuilder},
+    api::{
+        telemetry::{
+            metrics::CoreMeter, OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
+        },
+        worker::{WorkerConfig, WorkerConfigBuilder},
     },
-    api::worker::{WorkerConfig, WorkerConfigBuilder},
     ephemeral_server::{
         TemporalDevServerConfig, TemporalDevServerConfigBuilder, TestServerConfig,
         TestServerConfigBuilder,
     },
+    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
     ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TlsConfig, Url,
 };
 
@@ -44,7 +46,6 @@ impl ArrayHandleConversionsExt for Handle<'_, JsArray> {
 
 pub trait ObjectHandleConversionsExt {
     fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()>;
-    fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext>;
     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>;
@@ -60,19 +61,6 @@ pub trait ObjectHandleConversionsExt {
 }
 
 impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
-    fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext> {
-        let trace_id = js_value_getter!(ctx, self, "traceId", JsString);
-        let span_id = js_value_getter!(ctx, self, "spanId", JsString);
-        let trace_flags = js_value_getter!(ctx, self, "traceFlags", JsNumber);
-        Ok(SpanContext::new(
-            TraceId::from_hex(&trace_id).expect("TraceId is valid"),
-            SpanId::from_hex(&span_id).expect("SpanId is valid"),
-            TraceFlags::new(trace_flags as u8),
-            false,
-            TraceState::from_str("").expect("Trace state must be valid"),
-        ))
-    }
-
     fn as_hash_map_of_string_to_string(
         &self,
         cx: &mut FunctionContext,
@@ -178,10 +166,11 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-        telemetry_opts.no_temporal_prefix_for_metrics(
-            js_optional_value_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
-                .unwrap_or_default(),
-        );
+        if js_optional_value_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
+            .unwrap_or_default()
+        {
+            telemetry_opts.metric_prefix("".to_string());
+        }
 
         if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
             let filter = js_value_getter!(cx, logging, "filter", JsString);
@@ -197,52 +186,72 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         }
 
         if let Some(ref metrics) = js_optional_getter!(cx, self, "metrics", JsObject) {
-            if let Some(temporality) =
-                js_optional_value_getter!(cx, metrics, "temporality", JsString)
-            {
-                match temporality.as_str() {
-                    "cumulative" => {
-                        telemetry_opts.metric_temporality(MetricTemporality::Cumulative);
-                    }
-                    "delta" => {
-                        telemetry_opts.metric_temporality(MetricTemporality::Delta);
-                    }
-                    _ => {
-                        cx.throw_type_error("Invalid telemetryOptions.metrics.temporality, expected 'cumulative' or 'delta'")?;
-                    }
-                };
-            }
             if let Some(ref prom) = js_optional_getter!(cx, metrics, "prometheus", JsObject) {
+                if js_optional_getter!(cx, metrics, "otel", JsObject).is_some() {
+                    cx.throw_type_error(
+                        "Invalid telemetryOptions.metrics: can't have both premetheus and otel at the same time",
+                    )?
+                }
+
+                let mut options = PrometheusExporterOptionsBuilder::default();
+
                 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",
-                    )?,
+                    Ok(addr) => options.socket_addr(addr),
+                    Err(_) => {
+                        return cx.throw_type_error(
+                            "Invalid telemetryOptions.metrics.prometheus.bindAddress",
+                        )?
+                    }
                 };
+
+                let options = options
+                    .build()
+                    .expect("Failed to build prometheus exporter options");
+                let prom_info = start_prometheus_metric_exporter(options)
+                    .expect("Failed creating prometheus exporter");
+                telemetry_opts.metrics(prom_info.meter as Arc<dyn CoreMeter>);
             } else if let Some(ref otel) = js_optional_getter!(cx, metrics, "otel", JsObject) {
+                let mut options = OtelCollectorOptionsBuilder::default();
+
                 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")?,
+                match Url::parse(&url) {
+                    Ok(url) => options.url(url),
+                    Err(_) => {
+                        return cx.throw_type_error("Invalid telemetryOptions.metrics.otel.url")
+                    }
+                };
+
+                if let Some(ref headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                    options.headers(headers.as_hash_map_of_string_to_string(cx)?);
                 };
-                let headers =
-                    if let Some(ref headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
-                        headers.as_hash_map_of_string_to_string(cx)?
-                    } else {
-                        Default::default()
+
+                if let Some(metric_periodicity) =
+                    js_optional_value_getter!(cx, otel, "metricsExportInterval", JsNumber)
+                        .map(|f| f as u64)
+                {
+                    options.metric_periodicity(Duration::from_millis(metric_periodicity));
+                }
+
+                // FIXME: Move temporality to the otel object
+                if let Some(temporality) =
+                    js_optional_value_getter!(cx, metrics, "temporality", JsString)
+                {
+                    match temporality.as_str() {
+                        "cumulative" => options.metric_temporality(MetricTemporality::Cumulative),
+                        "delta" => options.metric_temporality(MetricTemporality::Delta),
+                        _ => {
+                            return cx.throw_type_error("Invalid telemetryOptions.metrics.temporality, expected 'cumulative' or 'delta'");
+                        }
                     };
-                let metric_periodicity = Some(Duration::from_millis(js_value_getter!(
-                    cx,
-                    otel,
-                    "metricsExportInterval",
-                    JsNumber
-                ) as u64));
-                telemetry_opts.metrics(MetricsExporter::Otel(OtelCollectorOptions {
-                    url,
-                    headers,
-                    metric_periodicity,
-                }));
+                };
+
+                let options = options
+                    .build()
+                    .expect("Failed to build otlp exporter options");
+                let otlp_exporter =
+                    build_otlp_metric_exporter(options).expect("Failed to build otlp exporter");
+                telemetry_opts.metrics(Arc::new(otlp_exporter) as Arc<dyn CoreMeter>);
             } else {
                 cx.throw_type_error(
                     "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option",
@@ -250,33 +259,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             }
         }
 
-        if let Some(ref tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
-            let filter = js_value_getter!(cx, tracing, "filter", JsString);
-            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(ref headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
-                        headers.as_hash_map_of_string_to_string(cx)?
-                    } else {
-                        Default::default()
-                    };
-                telemetry_opts.tracing(TraceExportConfig {
-                    filter,
-                    exporter: TraceExporter::Otel(OtelCollectorOptions {
-                        url,
-                        headers,
-                        metric_periodicity: None,
-                    }),
-                });
-            } else {
-                cx.throw_type_error("Invalid telemetryOptions.tracing, missing `otel` option")?
-            }
-        }
-
         telemetry_opts.build().map_err(|reason| {
             cx.throw_type_error::<_, TelemetryOptions>(format!("{}", reason))
                 .unwrap_err()
@@ -332,6 +314,9 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             js_optional_getter!(cx, self, "shutdownGraceTimeMs", JsNumber)
                 .map(|num| Duration::from_millis(num.value(cx) as u64));
 
+        let nonsticky_to_sticky_poll_ratio =
+            js_value_getter!(cx, self, "nonStickyToStickyPollRatio", JsNumber) as f32;
+
         match WorkerConfigBuilder::default()
             .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
             .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
@@ -342,6 +327,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .max_outstanding_local_activities(max_outstanding_local_activities)
             .max_concurrent_wft_polls(max_concurrent_wft_polls)
             .max_concurrent_at_polls(max_concurrent_at_polls)
+            .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
             .max_cached_workflows(max_cached_workflows)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
             .graceful_shutdown_period(graceful_shutdown_period)

package/src/helpers.rs

@@ -187,3 +187,77 @@ where
         cx.throw_type_error::<_, Vec<u8>>(format!("Invalid or missing {}", full_attr_path))
     }
 }
+
+// Recursively convert a Serde value to a JS value
+pub fn serde_value_to_js_value<'a>(
+    cx: &mut impl Context<'a>,
+    val: serde_json::Value,
+) -> JsResult<'a, JsValue> {
+    match val {
+        serde_json::Value::String(s) => Ok(cx.string(s).upcast()),
+        serde_json::Value::Number(n) => Ok(cx.number(n.as_f64().unwrap()).upcast()),
+        serde_json::Value::Bool(b) => Ok(cx.boolean(b).upcast()),
+        serde_json::Value::Null => Ok(cx.null().upcast()),
+        serde_json::Value::Array(vec) => {
+            let arr: Handle<'a, JsArray> = JsArray::new(cx, vec.len() as u32);
+            for (i, v) in vec.into_iter().enumerate() {
+                let v = serde_value_to_js_value(cx, v)?;
+                arr.set(cx, i as u32, v)?;
+            }
+            Ok(arr.upcast())
+        }
+        serde_json::Value::Object(map) => hashmap_to_js_value(cx, map).map(|v| v.upcast()),
+    }
+}
+
+pub fn hashmap_to_js_value<'a>(
+    cx: &mut impl Context<'a>,
+    map: impl IntoIterator<Item = (String, serde_json::Value)>,
+) -> JsResult<'a, JsObject> {
+    let obj: Handle<'a, JsObject> = cx.empty_object();
+    for (k, v) in map {
+        let k = cx.string(snake_to_camel(k));
+        let v = serde_value_to_js_value(cx, v)?;
+        obj.set(cx, k, v)?;
+    }
+    Ok(obj)
+}
+
+fn snake_to_camel(input: String) -> String {
+    match input.find('_') {
+        None => input,
+        Some(first) => {
+            let mut result = String::with_capacity(input.len());
+            if first > 0 {
+                result.push_str(&input[..first]);
+            }
+            let mut capitalize = true;
+            for c in input[first + 1..].chars() {
+                if c == '_' {
+                    capitalize = true;
+                } else if capitalize {
+                    result.push(c.to_ascii_uppercase());
+                    capitalize = false;
+                } else {
+                    result.push(c.to_ascii_lowercase());
+                }
+            }
+            result
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snake_to_camel_works() {
+        assert_eq!(snake_to_camel("this_is_a_test".into()), "thisIsATest");
+        assert_eq!(snake_to_camel("this___IS_a_TEST".into()), "thisIsATest");
+        assert_eq!(
+            snake_to_camel("éàç_this_is_a_test".into()),
+            "éàçThisIsATest"
+        );
+    }
+}

package/src/runtime.rs

@@ -14,8 +14,10 @@ use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClientWi
 use temporal_sdk_core::api::telemetry::{CoreTelemetry, TelemetryOptions};
 use temporal_sdk_core::CoreRuntime;
 use temporal_sdk_core::{
-    ephemeral_server::EphemeralServer as CoreEphemeralServer, init_replay_worker, init_worker,
-    replay::HistoryForReplay, ClientOptions, RetryClient, WorkerConfig,
+    ephemeral_server::EphemeralServer as CoreEphemeralServer,
+    init_replay_worker, init_worker,
+    replay::{HistoryForReplay, ReplayWorkerInput},
+    ClientOptions, RetryClient, WorkerConfig,
 };
 use tokio::sync::{
     mpsc::{channel, unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
@@ -149,7 +151,7 @@ pub fn start_bridge_loop(
                     core_runtime.tokio_handle().spawn(async move {
                         match options
                             .connect_no_namespace(
-                                runtime_clone.metric_meter().as_deref(),
+                                runtime_clone.telemetry().get_metric_meter(),
                                 headers.map(|h| Arc::new(RwLock::new(h))),
                             )
                             .await
@@ -195,15 +197,24 @@ pub fn start_bridge_loop(
                     send_result(channel.clone(), callback, |cx| {
                         let logarr = cx.empty_array();
                         for (i, cl) in logs.into_iter().enumerate() {
-                            // Not much to do here except for panic when there's an
-                            // error here.
+                            // Not much to do here except for panic when there's an error here.
                             let logobj = cx.empty_object();
+
                             let level = cx.string(cl.level.to_string());
                             logobj.set(cx, "level", level).unwrap();
+
                             let ts = system_time_to_js(cx, cl.timestamp).unwrap();
                             logobj.set(cx, "timestamp", ts).unwrap();
+
                             let msg = cx.string(cl.message);
                             logobj.set(cx, "message", msg).unwrap();
+
+                            let fieldsobj = hashmap_to_js_value(cx, cl.fields);
+                            logobj.set(cx, "fields", fieldsobj.unwrap()).unwrap();
+
+                            let target = cx.string(cl.target);
+                            logobj.set(cx, "target", target).unwrap();
+
                             logarr.set(cx, i as u32, logobj).unwrap();
                         }
                         Ok(logarr)
@@ -238,7 +249,7 @@ pub fn start_bridge_loop(
                     callback,
                 } => {
                     let (tunnel, stream) = HistoryForReplayTunnel::new(runtime);
-                    match init_replay_worker(config, Box::pin(stream)) {
+                    match init_replay_worker(ReplayWorkerInput::new(config, Box::pin(stream))) {
                         Ok(worker) => {
                             let (tx, rx) = unbounded_channel();
                             core_runtime.tokio_handle().spawn(start_worker_loop(