@temporalio/core-bridge 1.4.4 → 1.5.1

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

@@ -6,6 +6,7 @@ mod child_workflows;
 mod continue_as_new;
 mod determinism;
 mod local_activities;
+mod modify_wf_properties;
 mod patches;
 mod replay;
 mod resets;
@@ -28,6 +29,7 @@ use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{
     interceptors::WorkerInterceptor, ActContext, ActivityOptions, WfContext, WorkflowResult,
 };
+use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -37,7 +39,7 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
-    temporal::api::failure::v1::Failure,
+    temporal::api::{failure::v1::Failure, history::v1::history_event},
 };
 use temporal_sdk_core_test_utils::{
     history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
@@ -102,6 +104,7 @@ async fn parallel_workflows_same_queue() {
     for handle in handles {
         handle.await.unwrap()
     }
+    core.shutdown().await;
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -179,13 +182,20 @@ async fn shutdown_aborts_actively_blocked_poll() {
 #[tokio::test]
 async fn fail_wf_task(#[values(true, false)] replay: bool) {
     let core = if replay {
-        let (core, _) = init_core_replay_preloaded(
-            "fail_wf_task",
-            &history_from_proto_binary("histories/fail_wf_task.bin")
-                .await
-                .unwrap(),
-        );
-        core
+        // We need to send the history twice, since we fail it the first time.
+        let mut hist_proto = history_from_proto_binary("histories/fail_wf_task.bin")
+            .await
+            .unwrap();
+        let hist = HistoryForReplay::new(hist_proto.clone(), "fake".to_string());
+        if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(
+            ref mut attrs,
+        )) = hist_proto.events[0].attributes
+        {
+            attrs.original_execution_run_id = "run2".to_string();
+            attrs.first_execution_run_id = "run2".to_string();
+        }
+        let hist2 = HistoryForReplay::new(hist_proto, "fake".to_string());
+        init_core_replay_preloaded("fail_wf_task", [hist, hist2])
     } else {
         let mut starter = init_core_and_create_wf("fail_wf_task").await;
         starter.get_worker().await

package/sdk-core/tests/main.rs

@@ -20,6 +20,7 @@ mod integ_tests {
     mod client_tests;
     mod ephemeral_server_tests;
     mod heartbeat_tests;
+    mod metrics_tests;
     mod polling_tests;
     mod queries_tests;
     mod visibility_tests;
@@ -28,10 +29,10 @@ mod integ_tests {
     use std::str::FromStr;
     use temporal_client::WorkflowService;
     use temporal_sdk_core::{
-        init_worker, telemetry_init, ClientOptionsBuilder, ClientTlsConfig, TlsConfig,
+        init_worker, ClientOptionsBuilder, ClientTlsConfig, CoreRuntime, TlsConfig,
         WorkflowClientTrait,
     };
-    use temporal_sdk_core_api::{worker::WorkerConfigBuilder, CoreTelemetry};
+    use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
     use temporal_sdk_core_test_utils::{
         get_integ_server_options, get_integ_telem_options, NAMESPACE,
@@ -43,13 +44,14 @@ mod integ_tests {
     #[ignore] // Really a compile time check more than anything
     async fn lang_bridge_example() {
         let opts = get_integ_server_options();
-        let telem_d = telemetry_init(&get_integ_telem_options()).unwrap();
+        let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(telem_d.get_metric_meter(), None)
+            .connect_no_namespace(runtime.metric_meter(), None)
             .await
             .unwrap();
 
         let _worker = init_worker(
+            &runtime,
             WorkerConfigBuilder::default()
                 .namespace("default")
                 .task_queue("Wheee!")

package/src/conversions.rs

@@ -1,5 +1,4 @@
 use crate::helpers::*;
-use log::LevelFilter;
 use neon::{
     context::Context,
     handle::Handle,
@@ -9,13 +8,15 @@ use neon::{
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
 use std::{collections::HashMap, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
+    api::telemetry::{
+        Logger, MetricTemporality, MetricsExporter, OtelCollectorOptions, TelemetryOptions,
+        TelemetryOptionsBuilder, TraceExportConfig, TraceExporter,
+    },
     api::worker::{WorkerConfig, WorkerConfigBuilder},
     ephemeral_server::{
         TemporaliteConfig, TemporaliteConfigBuilder, TestServerConfig, TestServerConfigBuilder,
     },
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricTemporality,
-    MetricsExporter, OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder,
-    TlsConfig, TraceExporter, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TlsConfig, Url,
 };
 
 pub enum EphemeralServerConfig {
@@ -63,8 +64,8 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         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),
-            SpanId::from_hex(&span_id),
+            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"),
@@ -151,7 +152,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                 ) as u64),
                 max_elapsed_time: js_optional_value_getter!(
                     cx,
-                    &retry_config,
+                    retry_config,
                     "maxElapsedTime",
                     JsNumber
                 )
@@ -176,38 +177,27 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
-
-        if let Some(tf) = js_optional_value_getter!(cx, self, "tracingFilter", JsString) {
-            telemetry_opts.tracing_filter(tf);
-        }
         telemetry_opts.no_temporal_prefix_for_metrics(
             js_optional_value_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
                 .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
-                    ))?,
-                }
+            let filter = js_value_getter!(cx, logging, "filter", JsString);
+            if get_optional(cx, logging, "console").is_some() {
+                telemetry_opts.logging(Logger::Console { filter });
+            } else if get_optional(cx, logging, "forward").is_some() {
+                telemetry_opts.logging(Logger::Forward { filter });
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.logging, missing `console` or `forward` option"
-                ))?
+                cx.throw_type_error(
+                    "Invalid telemetryOptions.logging, expected either 'console' or 'forward' property",
+                )?;
             }
         }
-        if let Some(metrics) = js_optional_getter!(cx, self, "metrics", 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)
+                js_optional_value_getter!(cx, metrics, "temporality", JsString)
             {
                 match temporality.as_str() {
                     "cumulative" => {
@@ -221,8 +211,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     }
                 };
             }
-
-            if let Some(ref prom) = js_optional_getter!(cx, &metrics, "prometheus", 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)),
@@ -230,47 +219,63 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                         "Invalid telemetryOptions.metrics.prometheus.bindAddress",
                     )?,
                 };
-            } else if let Some(ref otel) = js_optional_getter!(cx, &metrics, "otel", JsObject) {
+            } 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) {
+                    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
-                    .metrics(MetricsExporter::Otel(OtelCollectorOptions { url, headers }));
+                let metric_periodicity = Some(Duration::from_millis(js_value_getter!(
+                    cx,
+                    otel,
+                    "metricPeriodicity",
+                    JsNumber
+                ) as u64));
+                telemetry_opts.metrics(MetricsExporter::Otel(OtelCollectorOptions {
+                    url,
+                    headers,
+                    metric_periodicity,
+                }));
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option"
-                ))?
+                cx.throw_type_error(
+                    "Invalid telemetryOptions.metrics, missing `prometheus` or `otel` option",
+                )?
             }
         }
 
-        if let Some(tracing) = js_optional_getter!(cx, self, "tracing", JsObject) {
-            if let Some(ref otel) = js_optional_getter!(cx, &tracing, "otel", 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(headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
+                    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(TraceExporter::Otel(OtelCollectorOptions { url, headers }));
+                telemetry_opts.tracing(TraceExportConfig {
+                    filter,
+                    exporter: TraceExporter::Otel(OtelCollectorOptions {
+                        url,
+                        headers,
+                        metric_periodicity: None,
+                    }),
+                });
             } else {
-                cx.throw_type_error(format!(
-                    "Invalid telemetryOptions.tracing, missing `otel` option"
-                ))?
+                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()
@@ -363,7 +368,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let executable = match exec_type.as_str() {
             "cached-download" => {
                 let version = js_optional_value_getter!(cx, &js_executable, "version", JsString)
-                    .unwrap_or("default".to_owned());
+                    .unwrap_or_else(|| "default".to_owned());
                 let dest_dir =
                     js_optional_value_getter!(cx, &js_executable, "downloadDir", JsString);
 

package/src/errors.rs

@@ -1,96 +1,38 @@
 use neon::prelude::*;
-use once_cell::sync::OnceCell;
 
 /// An unhandled error while communicating with the server, considered fatal
-pub static TRANSPORT_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
+pub static TRANSPORT_ERROR: &str = "TransportError";
 /// Thrown after shutdown was requested as a response to a poll function, JS should stop polling
 /// once this error is encountered
-pub static SHUTDOWN_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
+pub static SHUTDOWN_ERROR: &str = "ShutdownError";
 /// Something unexpected happened, considered fatal
-pub static UNEXPECTED_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
+pub static UNEXPECTED_ERROR: &str = "UnexpectedError";
 /// Used in different parts of the project to signal that something unexpected has happened
-pub static ILLEGAL_STATE_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
-
-static ALREADY_REGISTERED_ERRORS: OnceCell<bool> = OnceCell::new();
-
-/// This is one of the ways to implement custom errors in neon.
-/// Taken from the answer in GitHub issues: https://github.com/neon-bindings/neon/issues/714
-pub trait CustomError {
-    fn construct<'a, C>(&self, cx: &mut C, args: Vec<Handle<JsValue>>) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>;
-
-    fn from_string<'a, C>(&self, cx: &mut C, message: impl Into<String>) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>;
-
-    fn from_error<'a, C, E>(&self, cx: &mut C, err: E) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>,
-        E: std::error::Error;
-}
-
-// Implement `CustomError` for ALL errors in a `OnceCell`. This only needs to be
-// done _once_ even if other errors are added.
-impl CustomError for OnceCell<Root<JsFunction>> {
-    fn construct<'a, C>(&self, cx: &mut C, args: Vec<Handle<JsValue>>) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>,
-    {
-        let error = self
-            .get()
-            .expect("Expected module to be initialized")
-            .to_inner(cx);
-
-        // Use `.construct` to call this as a constructor instead of a normal function
-        error.construct(cx, args)
-    }
-
-    fn from_string<'a, C>(&self, cx: &mut C, message: impl Into<String>) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>,
-    {
-        let args = vec![cx.string(message.into()).upcast()];
-        self.construct(cx, args)
-    }
-
-    fn from_error<'a, C, E>(&self, cx: &mut C, err: E) -> JsResult<'a, JsObject>
-    where
-        C: Context<'a>,
-        E: std::error::Error,
-    {
-        self.from_string(cx, format!("{:?}", err))
-    }
+pub static ILLEGAL_STATE_ERROR: &str = "IllegalStateError";
+
+pub fn make_named_error_from_string<'a, C>(
+    cx: &mut C,
+    name: &str,
+    message: impl Into<String>,
+) -> JsResult<'a, JsError>
+where
+    C: Context<'a>,
+{
+    let error = cx.error(message.into()).unwrap();
+    let name = cx.string(name);
+    error.set(cx, "name", name)?;
+
+    Ok(error)
 }
 
-/// This method should be manually called _once_ from JavaScript to initialize the module
-/// It expects a single argument, an object with the various Error constructors.
-/// This is a very common pattern in Neon modules.
-pub fn register_errors(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let res = ALREADY_REGISTERED_ERRORS.set(true);
-    if res.is_err() {
-        // Don't do anything if errors are already registered
-        return Ok(cx.undefined());
-    }
-
-    let mapping = cx.argument::<JsObject>(0)?;
-    let shutdown_error = mapping
-        .get::<JsFunction, _, _>(&mut cx, "ShutdownError")?
-        .root(&mut cx);
-    let transport_error = mapping
-        .get::<JsFunction, _, _>(&mut cx, "TransportError")?
-        .root(&mut cx);
-    let unexpected_error = mapping
-        .get::<JsFunction, _, _>(&mut cx, "UnexpectedError")?
-        .root(&mut cx);
-    let illegal_state_error = mapping
-        .get::<JsFunction, _, _>(&mut cx, "IllegalStateError")?
-        .root(&mut cx);
-
-    TRANSPORT_ERROR.get_or_try_init(|| Ok(transport_error))?;
-    SHUTDOWN_ERROR.get_or_try_init(|| Ok(shutdown_error))?;
-    UNEXPECTED_ERROR.get_or_try_init(|| Ok(unexpected_error))?;
-    ILLEGAL_STATE_ERROR.get_or_try_init(|| Ok(illegal_state_error))?;
-
-    Ok(cx.undefined())
+pub fn make_named_error_from_error<'a, C, E>(
+    cx: &mut C,
+    name: &str,
+    err: E,
+) -> JsResult<'a, JsError>
+where
+    C: Context<'a>,
+    E: std::error::Error,
+{
+    make_named_error_from_string(cx, name, format!("{:?}", err))
 }

package/src/helpers.rs

@@ -1,6 +1,5 @@
 use crate::errors::*;
-use neon::prelude::*;
-use neon::types::buffer::TypedArray;
+use neon::{prelude::*, types::buffer::TypedArray};
 use std::{fmt::Display, future::Future, sync::Arc};
 
 /// Send a result to JS via callback using a [Channel]
@@ -59,11 +58,11 @@ pub fn callback_with_unexpected_error<'a, C, E>(
 ) -> NeonResult<()>
 where
     C: Context<'a>,
-    E: std::fmt::Display,
+    E: Display,
 {
     let err_str = format!("{}", err);
     callback_with_error(cx, callback, move |cx| {
-        UNEXPECTED_ERROR.from_string(cx, err_str)
+        make_named_error_from_string(cx, UNEXPECTED_ERROR, err_str)
     })
 }
 

package/src/lib.rs

@@ -13,13 +13,13 @@ use testing::*;
 #[neon::main]
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("getTimeOfDay", get_time_of_day)?;
-    cx.export_function("registerErrors", errors::register_errors)?;
-    cx.export_function("initTelemetry", init_telemetry)?;
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("newClient", client_new)?;
     cx.export_function("clientUpdateHeaders", client_update_headers)?;
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("newReplayWorker", replay_worker_new)?;
+    cx.export_function("pushHistory", push_history)?;
+    cx.export_function("closeHistoryStream", close_history_stream)?;
     cx.export_function("workerInitiateShutdown", worker_initiate_shutdown)?;
     cx.export_function("workerFinalizeShutdown", worker_finalize_shutdown)?;
     cx.export_function("clientClose", client_close)?;