@temporalio/core-bridge 1.3.0 → 1.4.0

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

@@ -105,7 +105,7 @@ async fn simple_query_legacy() {
     assert_eq!(&q_resp.unwrap()[0].data, query_resp);
 }
 
-#[rstest::rstest]
+#[rstest]
 #[case::no_eviction(false)]
 #[case::with_eviction(true)]
 #[tokio::test]

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

@@ -1,7 +1,6 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_sdk::{WfContext, Worker, WorkflowFunction};
-use temporal_sdk_core::telemetry_init;
 use temporal_sdk_core_api::errors::{PollActivityError, PollWfError};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -12,8 +11,7 @@ use temporal_sdk_core_protos::{
     DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    canned_histories, get_integ_telem_options, history_from_proto_binary,
-    init_core_replay_preloaded, WorkerTestHelpers,
+    canned_histories, history_from_proto_binary, init_core_replay_preloaded, WorkerTestHelpers,
 };
 use tokio::join;
 
@@ -101,7 +99,6 @@ async fn workflow_nondeterministic_replay() {
 
 #[tokio::test]
 async fn replay_using_wf_function() {
-    telemetry_init(&get_integ_telem_options()).unwrap();
     let num_timers = 10;
     let t = canned_histories::long_sequential_timers(num_timers as usize);
     let func = timers_wf(num_timers);
@@ -118,7 +115,6 @@ async fn replay_ok_ending_with_terminated_or_timed_out() {
     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(

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

@@ -1,8 +1,9 @@
-use std::collections::HashMap;
+use log::warn;
+use std::{collections::HashMap, env};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORALITE_USED_ENV_VAR};
 use uuid::Uuid;
 
 // These are initialized on the server as part of the autosetup container which we
@@ -24,6 +25,11 @@ async fn sends_upsert() {
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
     let mut worker = starter.worker().await;
+    if env::var(INTEG_TEMPORALITE_USED_ENV_VAR).is_ok() {
+        warn!("skipping sends_upsert -- does not work on temporalite");
+        return;
+    }
+
     worker.register_wf(wf_name, search_attr_updater);
     let run_id = worker
         .submit_wf(

package/sdk-core/tests/main.rs

@@ -1,4 +1,11 @@
 //! Integration tests
+//!
+//! Note that integ tests which want to use the server (nearly all of them) *need* to use the
+//! `#[rstest]` macro and accept the TODO fixture to support auto setup & teardown of ephemeral
+//! local servers.
+
+#[macro_use]
+extern crate rstest;
 
 #[cfg(test)]
 mod integ_tests {

package/sdk-core/tests/runner.rs

@@ -0,0 +1,93 @@
+use anyhow::{anyhow, bail};
+use std::{
+    env,
+    env::args,
+    path::{Path, PathBuf},
+    process::Stdio,
+};
+use temporal_sdk_core::ephemeral_server::{TemporaliteConfigBuilder, TestServerConfigBuilder};
+use temporal_sdk_core_test_utils::{
+    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORALITE_USED_ENV_VAR,
+    INTEG_TEST_SERVER_USED_ENV_VAR,
+};
+use tokio::{self, process::Command};
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+    let server_type = env::var("INTEG_SERVER_TYPE")
+        .unwrap_or_else(|_| "temporalite".to_string())
+        .to_lowercase();
+    // Try building first, so that we error early on build failures & don't start server
+    let status = Command::new(&cargo)
+        .args(["test", "--test", "integ_tests", "--no-run"])
+        .status()
+        .await?;
+    if !status.success() {
+        bail!("Building integration tests failed!");
+    }
+
+    // Move to clap if we start doing any more complicated input
+    let (server, envs) = if server_type == "test-server" {
+        let config = TestServerConfigBuilder::default()
+            .exe(default_cached_download())
+            .build()?;
+        println!("Using java test server");
+        (
+            Some(config.start_server_with_output(Stdio::null()).await?),
+            vec![(INTEG_TEST_SERVER_USED_ENV_VAR, "true")],
+        )
+    } else if server_type == "temporalite" {
+        let config = TemporaliteConfigBuilder::default()
+            .exe(default_cached_download())
+            .build()?;
+        println!("Using temporalite");
+        (
+            Some(config.start_server_with_output(Stdio::null()).await?),
+            vec![(INTEG_TEMPORALITE_USED_ENV_VAR, "true")],
+        )
+    } else {
+        println!("Not starting up a server. One should be running already.");
+        (None, vec![])
+    };
+
+    // Run the integ tests, passing through arguments
+    let mut args = args();
+    // Shift off binary name
+    args.next();
+    let mut cmd = Command::new(&cargo);
+    if let Some(srv) = server.as_ref() {
+        cmd.env(
+            INTEG_SERVER_TARGET_ENV_VAR,
+            format!("http://{}", &srv.target),
+        );
+    }
+    let status = cmd
+        .envs(envs)
+        .current_dir(project_root())
+        .args(
+            ["test", "--test", "integ_tests"]
+                .into_iter()
+                .map(ToString::to_string)
+                .chain(args),
+        )
+        .status()
+        .await?;
+
+    if let Some(mut srv) = server {
+        srv.shutdown().await?;
+    }
+    if status.success() {
+        Ok(())
+    } else {
+        Err(anyhow!("Integ tests failed!"))
+    }
+}
+
+fn project_root() -> PathBuf {
+    Path::new(&env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(1)
+        .unwrap()
+        .to_path_buf()
+}

package/src/conversions.rs

@@ -13,9 +13,9 @@ use temporal_sdk_core::{
     ephemeral_server::{
         TemporaliteConfig, TemporaliteConfigBuilder, TestServerConfig, TestServerConfigBuilder,
     },
-    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricsExporter,
-    OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder, TlsConfig,
-    TraceExporter, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricTemporality,
+    MetricsExporter, OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder,
+    TlsConfig, TraceExporter, Url,
 };
 
 pub enum EphemeralServerConfig {
@@ -206,6 +206,22 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             }
         }
         if let Some(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) {
                 let addr = js_value_getter!(cx, prom, "bindAddress", JsString);
                 match addr.parse::<SocketAddr>() {