@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core-api/src/envconfig.rs

@@ -138,9 +138,9 @@ pub struct ClientConfigProfile {
 /// ClientConfigTLS is TLS configuration for a client.
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct ClientConfigTLS {
-    /// If true, TLS is explicitly disabled. If false/unset, whether TLS is enabled or not depends on other factors such
-    /// as whether this struct is present or None, and whether API key exists (which enables TLS by default).
-    pub disabled: bool,
+    /// If Some(true), TLS is explicitly disabled. If Some(false), TLS is explicitly enabled.
+    /// If None, TLS behavior depends on other factors (API key presence, etc.)
+    pub disabled: Option<bool>,
 
     /// Client certificate source.
     pub client_cert: Option<DataSource>,
@@ -358,9 +358,6 @@ pub fn load_client_config_profile(
         profile.load_from_env(env_vars)?;
     }
 
-    // Apply API key → TLS auto-enabling logic
-    profile.apply_api_key_tls_logic();
-
     Ok(profile)
 }
 
@@ -446,7 +443,7 @@ impl ClientConfigProfile {
             if let Some(disabled_str) = env_provider.get("TEMPORAL_TLS")?
                 && let Some(disabled) = env_var_to_bool(&disabled_str)
             {
-                tls.disabled = !disabled;
+                tls.disabled = Some(!disabled);
             }
 
             apply_data_source_env_var(
@@ -528,14 +525,6 @@ impl ClientConfigProfile {
         }
         Ok(())
     }
-
-    /// Apply automatic TLS enabling when API key is present
-    pub fn apply_api_key_tls_logic(&mut self) {
-        if self.api_key.is_some() && self.tls.is_none() {
-            // If API key is present but no TLS config exists, create one with TLS enabled
-            self.tls = Some(ClientConfigTLS::default());
-        }
-    }
 }
 
 /// Helper to check if any of the given environment variables are set.
@@ -729,8 +718,8 @@ impl TomlClientConfigProfile {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct TomlClientConfigTLS {
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    disabled: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    disabled: Option<bool>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     client_cert_path: Option<String>,
@@ -760,7 +749,7 @@ struct TomlClientConfigTLS {
 impl TomlClientConfigTLS {
     fn new() -> Self {
         Self {
-            disabled: false,
+            disabled: None,
             client_cert_path: None,
             client_cert_data: None,
             client_key_path: None,
@@ -951,7 +940,7 @@ mod strict {
     #[serde(deny_unknown_fields)]
     struct StrictTomlClientConfigTLS {
         #[serde(default)]
-        disabled: bool,
+        disabled: Option<bool>,
         #[serde(default)]
         client_cert_path: Option<String>,
         #[serde(default)]
@@ -1068,7 +1057,7 @@ namespace = "production"
         assert_eq!(default_profile.api_key.as_ref().unwrap(), "test-key");
 
         let tls = default_profile.tls.as_ref().unwrap();
-        assert!(!tls.disabled);
+        assert_eq!(tls.disabled, Some(false)); // Explicitly set to false
         assert_eq!(
             tls.client_cert,
             Some(DataSource::Path("/path/to/cert".to_string()))
@@ -1244,7 +1233,7 @@ some-other-header = "some-value2"
         assert_eq!(profile.api_key.as_ref().unwrap(), "my-api-key-new");
 
         let tls = profile.tls.as_ref().unwrap();
-        assert!(!tls.disabled); // TLS enabled via env var
+        assert_eq!(tls.disabled, Some(false)); // TLS enabled via env var
         assert_eq!(
             tls.client_cert,
             Some(DataSource::Path("my-client-cert-path-new".to_string()))
@@ -1313,7 +1302,7 @@ sOme-hEader_key = "some-value"
         assert_eq!(codec.auth.as_ref().unwrap(), "my-auth");
 
         let tls = profile.tls.as_ref().unwrap();
-        assert!(tls.disabled);
+        assert_eq!(tls.disabled, Some(true)); // Explicitly disabled
         assert_eq!(
             tls.client_cert,
             Some(DataSource::Path("my-client-cert-path".to_string()))
@@ -1361,7 +1350,7 @@ api_key = "my-api-key"
         assert!(profile.tls.is_some());
 
         let tls = profile.tls.as_ref().unwrap();
-        assert!(!tls.disabled); // default value
+        assert_eq!(tls.disabled, None); // Not explicitly set // default value
         assert!(tls.client_cert.is_none());
     }
 
@@ -1582,27 +1571,6 @@ address = "localhost:7233"
         assert_eq!(profile.namespace.as_ref().unwrap(), "env-namespace");
     }
 
-    #[test]
-    fn test_api_key_tls_auto_enable() {
-        // Test 1: When API key is present, TLS should be automatically enabled
-        let toml_str = r#"
-[profile.default]
-api_key = "my-api-key"
-"#;
-
-        let options = LoadClientConfigProfileOptions {
-            config_source: Some(DataSource::Data(toml_str.as_bytes().to_vec())),
-            ..Default::default()
-        };
-
-        let profile = load_client_config_profile(options, None).unwrap();
-
-        // TLS should be enabled due to API key presence
-        assert!(profile.tls.is_some());
-        let tls = profile.tls.as_ref().unwrap();
-        assert!(!tls.disabled);
-    }
-
     #[test]
     fn test_no_api_key_no_tls_is_none() {
         // Test that if no API key is present and no TLS block exists, TLS config is None
@@ -1624,12 +1592,38 @@ address = "some-address"
 
     #[test]
     fn test_load_client_config_profile_from_system_env() {
-        // Set up system env vars. These tests can't be run in parallel.
-        unsafe {
-            std::env::set_var("TEMPORAL_ADDRESS", "system-address");
-            std::env::set_var("TEMPORAL_NAMESPACE", "system-namespace");
-        }
+        let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+        let output = std::process::Command::new(cargo)
+            .arg("test")
+            .arg("-F")
+            .arg("envconfig")
+            .arg("envconfig::tests::test_load_client_config_profile_from_system_env_impl")
+            .arg("--")
+            .arg("--exact")
+            .arg("--ignored")
+            .env("TEMPORAL_ADDRESS", "system-address")
+            .env("TEMPORAL_NAMESPACE", "system-namespace")
+            .output()
+            .expect("Failed to execute subprocess test");
 
+        assert!(
+            output.status.success(),
+            "Subprocess test failed:\nstdout: {}\nstderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr),
+        );
+    }
+
+    #[test]
+    #[ignore] // Only run when explicitly called
+    fn test_load_client_config_profile_from_system_env_impl() {
+        // Check if we're in the right context
+        if std::env::var("TEMPORAL_ADDRESS").is_err()
+            || std::env::var("TEMPORAL_NAMESPACE").is_err()
+        {
+            eprintln!("Skipping test - required env vars not set");
+            return; // Early return instead of panic
+        }
         let options = LoadClientConfigProfileOptions {
             disable_file: true, // Don't load from any files
             ..Default::default()
@@ -1639,11 +1633,116 @@ address = "some-address"
         let profile = load_client_config_profile(options, None).unwrap();
         assert_eq!(profile.address.as_ref().unwrap(), "system-address");
         assert_eq!(profile.namespace.as_ref().unwrap(), "system-namespace");
+    }
 
-        // Clean up
-        unsafe {
-            std::env::remove_var("TEMPORAL_ADDRESS");
-            std::env::remove_var("TEMPORAL_NAMESPACE");
-        }
+    #[test]
+    fn test_tls_disabled_tri_state_behavior() {
+        // Test 1: disabled = None (unset) - should not appear in TOML
+        let tls_unset = ClientConfigTLS {
+            disabled: None,
+            ..Default::default()
+        };
+        let profile_unset = ClientConfigProfile {
+            address: Some("localhost:7233".to_string()),
+            tls: Some(tls_unset),
+            ..Default::default()
+        };
+        let mut config_unset = ClientConfig::default();
+        config_unset
+            .profiles
+            .insert("test".to_string(), profile_unset);
+
+        let toml_unset = config_unset.to_toml().unwrap();
+        let toml_str_unset = String::from_utf8(toml_unset).unwrap();
+
+        // Unset disabled should not appear in TOML output
+        assert!(!toml_str_unset.contains("disabled"));
+
+        // Round-trip test - should remain None
+        let parsed_unset =
+            ClientConfig::from_toml(toml_str_unset.as_bytes(), Default::default()).unwrap();
+        assert_eq!(
+            parsed_unset
+                .profiles
+                .get("test")
+                .unwrap()
+                .tls
+                .as_ref()
+                .unwrap()
+                .disabled,
+            None
+        );
+
+        // Test 2: disabled = Some(false) (explicitly enabled) - should appear in TOML as false
+        let tls_enabled = ClientConfigTLS {
+            disabled: Some(false),
+            ..Default::default()
+        };
+        let profile_enabled = ClientConfigProfile {
+            address: Some("localhost:7233".to_string()),
+            tls: Some(tls_enabled),
+            ..Default::default()
+        };
+        let mut config_enabled = ClientConfig::default();
+        config_enabled
+            .profiles
+            .insert("test".to_string(), profile_enabled);
+
+        let toml_enabled = config_enabled.to_toml().unwrap();
+        let toml_str_enabled = String::from_utf8(toml_enabled).unwrap();
+
+        // Explicitly disabled=false should appear in TOML
+        assert!(toml_str_enabled.contains("disabled = false"));
+
+        // Round-trip test - should remain Some(false)
+        let parsed_enabled =
+            ClientConfig::from_toml(toml_str_enabled.as_bytes(), Default::default()).unwrap();
+        assert_eq!(
+            parsed_enabled
+                .profiles
+                .get("test")
+                .unwrap()
+                .tls
+                .as_ref()
+                .unwrap()
+                .disabled,
+            Some(false)
+        );
+
+        // Test 3: disabled = Some(true) (explicitly disabled) - should appear in TOML as true
+        let tls_disabled = ClientConfigTLS {
+            disabled: Some(true),
+            ..Default::default()
+        };
+        let profile_disabled = ClientConfigProfile {
+            address: Some("localhost:7233".to_string()),
+            tls: Some(tls_disabled),
+            ..Default::default()
+        };
+        let mut config_disabled = ClientConfig::default();
+        config_disabled
+            .profiles
+            .insert("test".to_string(), profile_disabled);
+
+        let toml_disabled = config_disabled.to_toml().unwrap();
+        let toml_str_disabled = String::from_utf8(toml_disabled).unwrap();
+
+        // Explicitly disabled=true should appear in TOML
+        assert!(toml_str_disabled.contains("disabled = true"));
+
+        // Round-trip test - should remain Some(true)
+        let parsed_disabled =
+            ClientConfig::from_toml(toml_str_disabled.as_bytes(), Default::default()).unwrap();
+        assert_eq!(
+            parsed_disabled
+                .profiles
+                .get("test")
+                .unwrap()
+                .tls
+                .as_ref()
+                .unwrap()
+                .disabled,
+            Some(true)
+        );
     }
 }

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

@@ -11,6 +11,7 @@ use crate::{
     },
     worker::WorkerConfig,
 };
+use std::sync::Arc;
 use temporal_sdk_core_protos::coresdk::{
     ActivityHeartbeat, ActivityTaskCompletion,
     activity_task::ActivityTask,
@@ -139,6 +140,73 @@ pub trait Worker: Send + Sync {
     async fn finalize_shutdown(self);
 }
 
+#[async_trait::async_trait]
+impl<W> Worker for Arc<W>
+where
+    W: Worker + ?Sized,
+{
+    async fn validate(&self) -> Result<(), WorkerValidationError> {
+        (**self).validate().await
+    }
+
+    async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollError> {
+        (**self).poll_workflow_activation().await
+    }
+
+    async fn poll_activity_task(&self) -> Result<ActivityTask, PollError> {
+        (**self).poll_activity_task().await
+    }
+
+    async fn poll_nexus_task(&self) -> Result<NexusTask, PollError> {
+        (**self).poll_nexus_task().await
+    }
+
+    async fn complete_workflow_activation(
+        &self,
+        completion: WorkflowActivationCompletion,
+    ) -> Result<(), CompleteWfError> {
+        (**self).complete_workflow_activation(completion).await
+    }
+
+    async fn complete_activity_task(
+        &self,
+        completion: ActivityTaskCompletion,
+    ) -> Result<(), CompleteActivityError> {
+        (**self).complete_activity_task(completion).await
+    }
+
+    async fn complete_nexus_task(
+        &self,
+        completion: NexusTaskCompletion,
+    ) -> Result<(), CompleteNexusError> {
+        (**self).complete_nexus_task(completion).await
+    }
+
+    fn record_activity_heartbeat(&self, details: ActivityHeartbeat) {
+        (**self).record_activity_heartbeat(details)
+    }
+
+    fn request_workflow_eviction(&self, run_id: &str) {
+        (**self).request_workflow_eviction(run_id)
+    }
+
+    fn get_config(&self) -> &WorkerConfig {
+        (**self).get_config()
+    }
+
+    fn initiate_shutdown(&self) {
+        (**self).initiate_shutdown()
+    }
+
+    async fn shutdown(&self) {
+        (**self).shutdown().await
+    }
+
+    async fn finalize_shutdown(self) {
+        panic!("Can't finalize shutdown on Arc'd worker")
+    }
+}
+
 macro_rules! dbg_panic {
   ($($arg:tt)*) => {
       use tracing::error;

package/sdk-core/core-api/src/telemetry/metrics.rs

@@ -1,4 +1,4 @@
-use crate::dbg_panic;
+use crate::{dbg_panic, telemetry::TaskQueueLabelStrategy};
 use std::{
     any::Any,
     borrow::Cow,
@@ -64,6 +64,7 @@ impl From<&'static str> for MetricParameters {
 pub struct TemporalMeter {
     pub inner: Arc<dyn CoreMeter>,
     pub default_attribs: NewAttributes,
+    pub task_queue_label_strategy: TaskQueueLabelStrategy,
 }
 
 impl Deref for TemporalMeter {

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

@@ -49,6 +49,9 @@ pub struct TelemetryOptions {
     /// all logging and traces.
     #[builder(setter(strip_option), default)]
     pub subscriber_override: Option<Arc<dyn Subscriber + Send + Sync>>,
+    /// See [TaskQueueLabelStrategy].
+    #[builder(default = "TaskQueueLabelStrategy::UseNormal")]
+    pub task_queue_label_strategy: TaskQueueLabelStrategy,
 }
 impl Debug for TelemetryOptions {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -80,6 +83,16 @@ impl Debug for TelemetryOptions {
     }
 }
 
+/// Determines how the `task_queue` label value is set on metrics.
+#[derive(Copy, Clone, Debug)]
+#[non_exhaustive]
+pub enum TaskQueueLabelStrategy {
+    /// Always use the normal task queue name, including for actions relating to sticky queues.
+    UseNormal,
+    /// Use the sticky queue name when recording metrics operating on sticky queues.
+    UseNormalAndSticky,
+}
+
 /// Options for exporting to an OpenTelemetry Collector
 #[derive(Debug, Clone, derive_builder::Builder)]
 pub struct OtelCollectorOptions {

package/sdk-core/core-c-bridge/Cargo.toml

@@ -10,22 +10,26 @@ crate-type = ["cdylib"]
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
+crossbeam-utils = "0.8"
 futures-util = { version = "0.3", default-features = false }
-http = "1.1"
+http = "1.3"
 libc = "0.2"
 prost = { workspace = true }
 # We rely on Cargo semver rules not updating a 0.x to 0.y. Per the rand
 # documentation, before 1.0, minor 0.x updates _can_ break portability which can
 # cause non-determinism.
-rand = "0.8.5"
-rand_pcg = "0.3.1"
+rand = "0.9.2"
+rand_pcg = "0.9.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-tokio = "1.26"
+tokio = "1.47"
 tokio-stream = "0.1"
 tokio-util = "0.7"
 tonic = { workspace = true }
 tracing = "0.1"
-url = "2.2"
+url = "2.5"
+# This is only needed as an explicit dependency so we can enable static as a feature
+xz2 = { version = "0.1" }
 
 [dependencies.temporal-client]
 path = "../client"
@@ -36,6 +40,7 @@ features = ["ephemeral-server"]
 
 [dependencies.temporal-sdk-core-api]
 path = "../core-api"
+features = ["envconfig"]
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
@@ -44,8 +49,8 @@ path = "../sdk-core-protos"
 futures-util = "0.3"
 thiserror = { workspace = true }
 
-[dev-dependencies.temporal-sdk-core-test-utils]
-path = "../test-utils"
-
 [build-dependencies]
 cbindgen = { version = "0.29", default-features = false }
+
+[features]
+xz2-static = ["xz2/static"]