@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/{core-api → crates/common}/src/telemetry.rs

@@ -1,3 +1,5 @@
+//! Contains tracing/logging and metrics related functionality
+
 pub mod metrics;
 
 use crate::telemetry::metrics::CoreMeter;
@@ -49,6 +51,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 +85,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 {
@@ -160,7 +175,7 @@ pub enum Logger {
         filter: String,
     },
     /// Push logs to Lang. Can be used with
-    /// temporal_sdk_core::telemetry::log_export::CoreLogBufferedConsumer to buffer.
+    /// temporalio_sdk_core::telemetry::log_export::CoreLogBufferedConsumer to buffer.
     Push {
         /// An [EnvFilter](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html) filter string.
         filter: String,

package/sdk-core/{core-api → crates/common}/src/worker.rs

@@ -1,4 +1,16 @@
-use crate::{errors::WorkflowErrorType, telemetry::metrics::TemporalMeter};
+//! Contains types that are needed by both the client and the sdk when configuring / interacting
+//! with workers.
+
+use crate::{
+    errors::WorkflowErrorType,
+    protos::{
+        coresdk,
+        coresdk::{ActivitySlotInfo, LocalActivitySlotInfo, NexusSlotInfo, WorkflowSlotInfo},
+        temporal,
+        temporal::api::{enums::v1::VersioningBehavior, worker::v1::PluginInfo},
+    },
+    telemetry::metrics::TemporalMeter,
+};
 use std::{
     any::Any,
     collections::{HashMap, HashSet},
@@ -6,12 +18,74 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporal_sdk_core_protos::{
-    coresdk,
-    coresdk::{ActivitySlotInfo, LocalActivitySlotInfo, NexusSlotInfo, WorkflowSlotInfo},
-    temporal,
-    temporal::api::enums::v1::VersioningBehavior,
-};
+
+/// Specifies which task types a worker will poll for.
+///
+/// Workers can be configured to handle any combination of workflows, activities, and nexus operations.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct WorkerTaskTypes {
+    pub enable_workflows: bool,
+    pub enable_local_activities: bool,
+    pub enable_remote_activities: bool,
+    pub enable_nexus: bool,
+}
+
+impl WorkerTaskTypes {
+    /// Check if no task types are enabled
+    pub fn is_empty(&self) -> bool {
+        !self.enable_workflows
+            && !self.enable_local_activities
+            && !self.enable_remote_activities
+            && !self.enable_nexus
+    }
+
+    /// Create a config with all task types enabled
+    pub fn all() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: true,
+            enable_local_activities: true,
+            enable_remote_activities: true,
+            enable_nexus: true,
+        }
+    }
+
+    /// Create a config with only workflow tasks enabled
+    pub fn workflow_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: true,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        }
+    }
+
+    /// Create a config with only activity tasks enabled
+    pub fn activity_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: true,
+            enable_nexus: false,
+        }
+    }
+
+    /// Create a config with only nexus tasks enabled
+    pub fn nexus_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: true,
+        }
+    }
+
+    pub fn overlaps_with(&self, other: &WorkerTaskTypes) -> bool {
+        (self.enable_workflows && other.enable_workflows)
+            || (self.enable_local_activities && other.enable_local_activities)
+            || (self.enable_remote_activities && other.enable_remote_activities)
+            || (self.enable_nexus && other.enable_nexus)
+    }
+}
 
 /// Defines per-worker configuration options
 #[derive(Clone, derive_builder::Builder)]
@@ -61,10 +135,10 @@ pub struct WorkerConfig {
     /// worker's task queue
     #[builder(default = "PollerBehavior::SimpleMaximum(5)")]
     pub nexus_task_poller_behavior: PollerBehavior,
-    /// If set to true this worker will only handle workflow tasks and local activities, it will not
-    /// poll for activity tasks.
-    #[builder(default = "false")]
-    pub no_remote_activities: bool,
+    /// Specifies which task types this worker will poll for.
+    ///
+    /// Note: At least one task type must be specified or the worker will fail validation.
+    pub task_types: WorkerTaskTypes,
     /// How long a workflow task is allowed to sit on the sticky queue before it is timed out
     /// and moved to the non-sticky queue where it may be picked up by any worker.
     #[builder(default = "Duration::from_secs(10)")]
@@ -141,19 +215,19 @@ pub struct WorkerConfig {
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_workflow_tasks: Option<usize>,
-    /// The maximum number of activity tasks that will ever be given to this worker concurrently
+    /// The maximum number of activity tasks that will ever be given to this worker concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_activities: Option<usize>,
     /// The maximum number of local activity tasks that will ever be given to this worker
-    /// concurrently
+    /// concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_local_activities: Option<usize>,
     /// The maximum number of nexus tasks that will ever be given to this worker
-    /// concurrently
+    /// concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
@@ -162,11 +236,13 @@ pub struct WorkerConfig {
     /// A versioning strategy for this worker.
     pub versioning_strategy: WorkerVersioningStrategy,
 
-    /// The interval within which the worker will send a heartbeat.
-    /// The timer is reset on each existing RPC call that also happens to send this data, like
-    /// `PollWorkflowTaskQueueRequest`.
+    /// List of plugins used by lang.
     #[builder(default)]
-    pub heartbeat_interval: Option<Duration>,
+    pub plugins: HashSet<PluginInfo>,
+
+    /// Skips the single worker+client+namespace+task_queue check
+    #[builder(default = "false")]
+    pub skip_client_worker_set_check: bool,
 }
 
 impl WorkerConfig {
@@ -213,6 +289,18 @@ impl WorkerConfigBuilder {
     }
 
     fn validate(&self) -> Result<(), String> {
+        let task_types = self
+            .task_types
+            .as_ref()
+            .cloned()
+            .unwrap_or_else(WorkerTaskTypes::all);
+        if task_types.is_empty() {
+            return Err("At least one task type must be enabled in `task_types`".to_owned());
+        }
+        if !task_types.enable_workflows && task_types.enable_local_activities {
+            return Err("`task_types` cannot enable local activities without workflows".to_owned());
+        }
+
         if let Some(b) = self.workflow_task_poller_behavior.as_ref() {
             b.validate()?
         }
@@ -363,6 +451,12 @@ pub trait SlotSupplier {
     fn available_slots(&self) -> Option<usize> {
         None
     }
+
+    /// Returns a human-friendly identifier describing this supplier implementation for
+    /// diagnostics and telemetry.
+    fn slot_supplier_kind(&self) -> String {
+        "Custom".to_string()
+    }
 }
 
 pub trait SlotReservationContext: Send + Sync {

package/sdk-core/crates/common/tests/worker_task_types_test.rs

@@ -0,0 +1,129 @@
+use temporalio_common::worker::{WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy};
+
+fn default_versioning_strategy() -> WorkerVersioningStrategy {
+    WorkerVersioningStrategy::None {
+        build_id: String::new(),
+    }
+}
+
+#[test]
+fn test_default_configuration_polls_all_types() {
+    let config = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes::all())
+        .build()
+        .expect("Failed to build default config");
+
+    let effective = &config.task_types;
+    assert!(
+        effective.enable_workflows,
+        "Should poll workflows by default"
+    );
+    assert!(
+        effective.enable_local_activities,
+        "should poll local activities by default"
+    );
+    assert!(
+        effective.enable_remote_activities,
+        "Should poll remote activities by default"
+    );
+    assert!(effective.enable_nexus, "Should poll nexus by default");
+}
+
+#[test]
+fn test_invalid_task_types_fails_validation() {
+    // empty task types
+    let result = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        })
+        .build();
+
+    assert!(result.is_err(), "Empty task_types should fail validation");
+    let err = result.err().unwrap().to_string();
+    assert!(
+        err.contains("At least one task type"),
+        "Error should mention task types: {err}",
+    );
+
+    // local activities with no workflows
+    let result = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: true,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        })
+        .build();
+
+    assert!(result.is_err(), "Empty task_types should fail validation");
+    let err = result.err().unwrap().to_string();
+    assert!(
+        err.contains("cannot enable local activities without workflows"),
+        "Error should mention task types: {err}",
+    );
+}
+
+#[test]
+fn test_all_combinations() {
+    let combinations = [
+        (WorkerTaskTypes::workflow_only(), "workflows only"),
+        (WorkerTaskTypes::activity_only(), "activities only"),
+        (WorkerTaskTypes::nexus_only(), "nexus only"),
+        (
+            WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: true,
+                enable_remote_activities: true,
+                enable_nexus: false,
+            },
+            "workflows + activities",
+        ),
+        (
+            WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: true,
+                enable_remote_activities: false,
+                enable_nexus: true,
+            },
+            "workflows + nexus",
+        ),
+        (
+            WorkerTaskTypes {
+                enable_workflows: false,
+                enable_local_activities: false,
+                enable_remote_activities: true,
+                enable_nexus: true,
+            },
+            "activities + nexus",
+        ),
+        (WorkerTaskTypes::all(), "all types"),
+    ];
+
+    for (task_types, description) in combinations {
+        let config = WorkerConfigBuilder::default()
+            .namespace("default")
+            .task_queue("test-queue")
+            .versioning_strategy(default_versioning_strategy())
+            .task_types(task_types)
+            .build()
+            .unwrap_or_else(|e| panic!("Failed to build config for {description}: {e:?}"));
+
+        let effective = config.task_types;
+        assert_eq!(
+            effective, task_types,
+            "Effective types should match for {description}",
+        );
+    }
+}

package/sdk-core/crates/macros/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "temporalio-macros"
+version = "0.1.0"
+edition = "2024"
+authors = ["Temporal Technologies Inc. <sdk@temporal.io>"]
+license-file = { workspace = true }
+description = "Procmacros used in Temporal Core & Rust SDKs"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+derive_more = { workspace = true }
+proc-macro2 = "1.0"
+syn = { version = "2.0", features = ["default", "extra-traits"] }
+quote = "1.0"
+
+[dev-dependencies]
+# This is to enable doctests for the macros
+temporalio-common = { path = "../common" }
+
+[package.metadata.workspaces]
+independent = true

package/sdk-core/{fsm/rustfsm_procmacro → crates/macros}/src/lib.rs

@@ -13,10 +13,9 @@ use syn::{
 ///
 /// An example state machine definition of a card reader for unlocking a door:
 /// ```
-/// # extern crate rustfsm_trait as rustfsm;
-/// use rustfsm_procmacro::fsm;
+/// use temporalio_macros::fsm;
 /// use std::convert::Infallible;
-/// use rustfsm_trait::{StateMachine, TransitionResult};
+/// use temporalio_common::fsm_trait::{StateMachine, TransitionResult};
 ///
 /// fsm! {
 ///     name CardReader; command Commands; error Infallible; shared_state SharedState;
@@ -434,6 +433,7 @@ impl StateMachineDefinition {
             }
         };
         let mut multi_dest_enums = vec![];
+        let mut multi_dest_enum_names = HashSet::new();
         let state_branches: Vec<_> = statemap.into_iter().map(|(from, transitions)| {
             let occupied_current_state = quote! { Some(#state_enum_name::#from(state_data)) };
             // Merge transition dest states with the same handler
@@ -468,7 +468,11 @@ impl StateMachineDefinition {
                                         }
                                     }
                                 };
-                                multi_dest_enums.push(multi_dest_enum);
+                                // Deduplicate; two different events may each result in a transition
+                                // set with the same set of dest states
+                                if multi_dest_enum_names.insert(enum_ident.clone()) {
+                                    multi_dest_enums.push(multi_dest_enum);
+                                }
                                 quote! {
                                     #transition_result_name<#enum_ident>
                                 }
@@ -538,7 +542,7 @@ impl StateMachineDefinition {
                     quote! { _ => {
                         // Restore state in event the transition doesn't match
                         self.state = #occupied_current_state;
-                        return Err(::rustfsm::MachineError::InvalidTransition)
+                        return Err(::temporalio_common::fsm_trait::MachineError::InvalidTransition)
                     } },
                 ));
             quote! {
@@ -548,14 +552,14 @@ impl StateMachineDefinition {
             }
         }).chain(std::iter::once(
             quote! {
-                None => Err(::rustfsm::MachineError::InvalidTransition)
+                None => Err(::temporalio_common::fsm_trait::MachineError::InvalidTransition)
             }
         )).collect();
 
         let viz_str = self.visualize();
 
         let trait_impl = quote! {
-            impl ::rustfsm::StateMachine for #name {
+            impl ::temporalio_common::fsm_trait::StateMachine for #name {
                 type Error = #err_type;
                 type State = #state_enum_name;
                 type SharedState = #shared_state_type;
@@ -568,7 +572,7 @@ impl StateMachineDefinition {
 
                 fn on_event(&mut self, event: #events_enum_name)
                   -> ::core::result::Result<::std::vec::Vec<Self::Command>,
-                                            ::rustfsm::MachineError<Self::Error>> {
+                                            ::temporalio_common::fsm_trait::MachineError<Self::Error>> {
                     let taken_state = self.state.take();
                     match taken_state {
                         #(#state_branches),*
@@ -579,10 +583,6 @@ impl StateMachineDefinition {
                     self.state.as_ref().unwrap()
                 }
 
-                fn set_state(&mut self, new: Self::State) {
-                    self.state = Some(new)
-                }
-
                 fn shared_state(&self) -> &Self::SharedState{
                     &self.shared_state
                 }

package/sdk-core/{sdk → crates/sdk}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "temporal-sdk"
+name = "temporalio-sdk"
 version = "0.1.0-alpha.1"
 edition = "2024"
 authors = ["Spencer Judge <spencer@temporal.io>"]
@@ -16,29 +16,35 @@ anyhow = "1.0"
 derive_more = { workspace = true }
 futures-util = { version = "0.3", default-features = false }
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = { version = "0.6", package = "prost-wkt-types" }
+prost-types = { workspace = true }
 serde = "1.0"
-tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio = { version = "1.47", features = [
+    "rt",
+    "rt-multi-thread",
+    "parking_lot",
+    "time",
+    "fs",
+] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tracing = "0.1"
 
-[dependencies.temporal-sdk-core]
-path = "../core"
+[dependencies.temporalio-sdk-core]
+path = "../sdk-core"
 version = "0.1"
 default-features = false
 
-[dependencies.temporal-sdk-core-protos]
-path = "../sdk-core-protos"
+[dependencies.temporalio-common]
+path = "../common"
 version = "0.1"
 
-[dependencies.temporal-sdk-core-api]
-path = "../core-api"
-version = "0.1"
-
-[dependencies.temporal-client]
+[dependencies.temporalio-client]
 path = "../client"
 version = "0.1"
 
+[features]
+default = []
+antithesis_assertions = ["temporalio-sdk-core/antithesis_assertions"]
+
 [lints]
 workspace = true

package/sdk-core/{sdk → crates/sdk}/src/activity_context.rs

@@ -6,12 +6,14 @@ use std::{
     sync::Arc,
     time::{Duration as StdDuration, SystemTime},
 };
-use temporal_client::Priority;
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::{
-    coresdk::{ActivityHeartbeat, activity_task},
-    temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
-    utilities::TryIntoOrNone,
+use temporalio_client::Priority;
+use temporalio_common::{
+    Worker,
+    protos::{
+        coresdk::{ActivityHeartbeat, activity_task},
+        temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
+        utilities::TryIntoOrNone,
+    },
 };
 use tokio_util::sync::CancellationToken;
 
@@ -56,7 +58,7 @@ pub struct ActivityInfo {
 impl ActContext {
     /// Construct new Activity Context, returning the context and the first argument to the activity
     /// (which may be a default [Payload]).
-    pub(crate) fn new(
+    pub fn new(
         worker: Arc<dyn Worker>,
         app_data: Arc<AppData>,
         cancellation_token: CancellationToken,

package/sdk-core/{sdk → crates/sdk}/src/app_data.rs

@@ -6,7 +6,7 @@ use std::{
 
 /// A Wrapper Type for workflow and activity app data
 #[derive(Default)]
-pub(crate) struct AppData {
+pub struct AppData {
     map: HashMap<TypeId, Box<dyn Any + Send + Sync>>,
 }
 

package/sdk-core/{sdk → crates/sdk}/src/interceptors.rs

@@ -3,7 +3,7 @@
 use crate::Worker;
 use anyhow::bail;
 use std::sync::{Arc, OnceLock};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         workflow_activation::{WorkflowActivation, remove_from_cache::EvictionReason},
         workflow_completion::WorkflowActivationCompletion,
@@ -88,10 +88,7 @@ impl WorkerInterceptor for FailOnNondeterminismInterceptor {
             activation.eviction_reason(),
             Some(EvictionReason::Nondeterminism)
         ) {
-            bail!(
-                "Workflow is being evicted because of nondeterminism! {}",
-                activation
-            );
+            bail!("Workflow is being evicted because of nondeterminism! {activation}");
         }
         Ok(())
     }