@temporalio/core-bridge 1.5.2 → 1.6.0

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -172,7 +172,7 @@ impl EphemeralServer {
             .stdout(config.output)
             .spawn()?;
         let target = format!("127.0.0.1:{}", config.port);
-        let target_url = format!("http://{}", target);
+        let target_url = format!("http://{target}");
         let success = Ok(EphemeralServer {
             target,
             has_test_service: config.has_test_service,
@@ -304,9 +304,9 @@ impl EphemeralExe {
                     EphemeralExeVersion::Default {
                         sdk_name,
                         sdk_version,
-                    } => format!("{}-{}-{}{}", artifact_name, sdk_name, sdk_version, out_ext),
+                    } => format!("{artifact_name}-{sdk_name}-{sdk_version}{out_ext}"),
                     EphemeralExeVersion::Fixed(version) => {
-                        format!("{}-{}{}", artifact_name, version, out_ext)
+                        format!("{artifact_name}-{version}{out_ext}")
                     }
                 });
                 debug!(
@@ -340,8 +340,7 @@ impl EphemeralExe {
                 let client = reqwest::Client::new();
                 let info: DownloadInfo = client
                     .get(format!(
-                        "https://temporal.download/{}/{}",
-                        artifact_name, version_name
+                        "https://temporal.download/{artifact_name}/{version_name}"
                     ))
                     .query(&get_info_params)
                     .send()
@@ -371,7 +370,7 @@ impl EphemeralExe {
 fn get_free_port(bind_ip: &str) -> u16 {
     // Can just ask OS to give us a port then close socket. OS's don't give that
     // port back to anyone else anytime soon.
-    std::net::TcpListener::bind(format!("{}:0", bind_ip))
+    std::net::TcpListener::bind(format!("{bind_ip}:0"))
         .unwrap()
         .local_addr()
         .unwrap()

package/sdk-core/core/src/lib.rs

@@ -36,6 +36,8 @@ pub use temporal_sdk_core_api as api;
 pub use temporal_sdk_core_protos as protos;
 pub use temporal_sdk_core_protos::TaskToken;
 pub use url::Url;
+#[cfg(feature = "save_wf_inputs")]
+pub use worker::replay_wf_state_inputs;
 pub use worker::{Worker, WorkerConfig, WorkerConfigBuilder};
 
 use crate::{

package/sdk-core/core/src/protosext/mod.rs

@@ -274,7 +274,7 @@ impl TryFrom<activity_execution_result::Status> for LocalActivityExecutionResult
             Status::Failed(f)
                 if f.failure
                     .as_ref()
-                    .map(|fail| fail.is_timeout())
+                    .map(|fail| fail.is_timeout().is_some())
                     .unwrap_or_default() =>
             {
                 Ok(LocalActivityExecutionResult::TimedOut(f))

package/sdk-core/core/src/telemetry/log_export.rs

@@ -139,7 +139,7 @@ impl<'a> tracing::field::Visit for JsonVisitor<'a> {
     fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
         self.0.insert(
             field.name().to_string(),
-            serde_json::json!(format!("{:?}", value)),
+            serde_json::json!(format!("{value:?}")),
         );
     }
 }

package/sdk-core/core/src/telemetry/mod.rs

@@ -25,7 +25,17 @@ use opentelemetry::{
 };
 use opentelemetry_otlp::WithExportConfig;
 use parking_lot::Mutex;
-use std::{cell::RefCell, collections::VecDeque, convert::TryInto, env, sync::Arc, time::Duration};
+use std::{
+    cell::RefCell,
+    collections::VecDeque,
+    convert::TryInto,
+    env,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
 use temporal_sdk_core_api::telemetry::{
     CoreLog, CoreTelemetry, Logger, MetricTemporality, MetricsExporter, OtelCollectorOptions,
     TelemetryOptions, TraceExporter,
@@ -37,12 +47,10 @@ use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Layer};
 const TELEM_SERVICE_NAME: &str = "temporal-core-sdk";
 
 /// Help you construct an [EnvFilter] compatible filter string which will forward all core module
-/// traces at `core_level` and all others (from 3rd party modules, etc) at `other_levl.
+/// traces at `core_level` and all others (from 3rd party modules, etc) at `other_level`.
 pub fn construct_filter_string(core_level: Level, other_level: Level) -> String {
     format!(
-        "{o},temporal_sdk_core={l},temporal_client={l},temporal_sdk={l}",
-        o = other_level,
-        l = core_level
+        "{other_level},temporal_sdk_core={core_level},temporal_client={core_level},temporal_sdk={core_level}"
     )
 }
 
@@ -295,10 +303,17 @@ pub fn telemetry_init(opts: TelemetryOptions) -> Result<TelemetryInstance, anyho
     }
 }
 
-/// Initialize telemetry/tracing globally. Useful for testing.
+/// Initialize telemetry/tracing globally. Useful for testing. Only takes affect when called
+/// the first time. Subsequent calls are ignored.
 pub fn telemetry_init_global(opts: TelemetryOptions) -> Result<(), anyhow::Error> {
-    let ti = telemetry_init(opts)?;
-    tracing::subscriber::set_global_default(ti.trace_subscriber())?;
+    static INITTED: AtomicBool = AtomicBool::new(false);
+    if INITTED
+        .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+        .is_ok()
+    {
+        let ti = telemetry_init(opts)?;
+        tracing::subscriber::set_global_default(ti.trace_subscriber())?;
+    }
     Ok(())
 }
 

package/sdk-core/core/src/test_help/mod.rs

@@ -379,6 +379,7 @@ pub(crate) struct MockPollCfg {
     /// early with no work, since we cannot know the exact number of times polling will happen.
     /// Instead, they will just block forever.
     pub using_rust_sdk: bool,
+    pub make_poll_stream_interminable: bool,
 }
 
 impl MockPollCfg {
@@ -396,6 +397,7 @@ impl MockPollCfg {
             expect_fail_wft_matcher: Box::new(|_, _, _| true),
             completion_asserts: None,
             using_rust_sdk: false,
+            make_poll_stream_interminable: false,
         }
     }
     pub fn from_resp_batches(
@@ -417,6 +419,7 @@ impl MockPollCfg {
             expect_fail_wft_matcher: Box::new(|_, _, _| true),
             completion_asserts: None,
             using_rust_sdk: false,
+            make_poll_stream_interminable: false,
         }
     }
 }
@@ -612,11 +615,15 @@ pub(crate) fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder {
             Ok(Default::default())
         });
 
-    MocksHolder {
+    let mut mh = MocksHolder {
         client: Arc::new(cfg.mock_client),
         inputs: mock_worker,
         outstanding_task_map: Some(outstanding_wf_task_tokens),
+    };
+    if cfg.make_poll_stream_interminable {
+        mh.make_wft_stream_interminable();
     }
+    mh
 }
 
 pub struct QueueResponse<T> {