@temporalio/core-bridge 1.15.0 → 1.16.1

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

@@ -9,35 +9,28 @@ homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"
 keywords = ["temporal", "workflow"]
 categories = ["development-tools"]
+exclude = ["machine_coverage/*"]
 
 [lib]
 
 [features]
-default = ["otel", "prom"]
-otel = [
-    "dep:opentelemetry",
-    "dep:opentelemetry_sdk",
-    "dep:opentelemetry-otlp",
-    "dep:hyper",
-    "dep:hyper-util",
-    "dep:http-body-util",
-]
-prom = ["dep:prometheus"]
-tokio-console = ["console-subscriber"]
+default = ["otel"]
+otel = ["dep:opentelemetry", "dep:opentelemetry_sdk", "dep:opentelemetry-otlp"]
 ephemeral-server = ["dep:flate2", "dep:reqwest", "dep:tar", "dep:zip"]
-debug-plugin = ["dep:reqwest"]
+debug-plugin = ["dep:reqwest", "dep:hyper"]
 test-utilities = ["dep:assert_matches", "dep:bimap"]
 antithesis_assertions = ["dep:antithesis_sdk"]
 
 [dependencies]
 anyhow = "1.0"
-antithesis_sdk = { version = "0.2.1", optional = true, default-features = false, features = ["full"] }
+antithesis_sdk = { version = "0.2.1", optional = true, default-features = false, features = [
+  "full",
+] }
 assert_matches = { version = "1.5", optional = true }
 backoff = "0.4"
 bimap = { version = "0.6.3", optional = true }
 async-trait = "0.1"
 bon = { workspace = true }
-console-subscriber = { version = "0.4", optional = true }
 crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
 crossbeam-utils = "0.8"
@@ -46,49 +39,38 @@ derive_more = { workspace = true }
 enum_dispatch = "0.3"
 enum-iterator = "2"
 flate2 = { version = "1.1", optional = true }
+futures = { version = "0.3", default-features = false }
 futures-util = { version = "0.3", default-features = false }
-futures-channel = { version = "0.3", default-features = false, features = [
-    "std",
-] }
 gethostname = "1.0.2"
 governor = "0.10"
-http-body-util = { version = "0.1", optional = true }
 hyper = { version = "1.7", optional = true }
-hyper-util = { version = "0.1", features = [
-    "server",
-    "http1",
-    "http2",
-    "tokio",
-], optional = true }
 itertools = "0.14"
 lru = "0.16"
 mockall = "0.13"
 opentelemetry = { workspace = true, features = ["metrics"], optional = true }
 opentelemetry_sdk = { version = "0.31", features = [
-    "rt-tokio",
-    "metrics",
-    "spec_unstable_metrics_views",
+  "rt-tokio",
+  "metrics",
+  "spec_unstable_metrics_views",
 ], optional = true }
 opentelemetry-otlp = { version = "0.31", features = [
-    "tokio",
-    "metrics",
-    "tls",
-    "http-proto",
-    "grpc-tonic",
+  "tokio",
+  "metrics",
+  "tls",
+  "http-proto",
+  "grpc-tonic",
 ], optional = true }
 parking_lot = { version = "0.12", features = ["send_guard"] }
 pid = "4.0"
 pin-project = "1.1"
-prometheus = { version = "0.14", optional = true }
 prost = { workspace = true }
 prost-types = { workspace = true }
 rand = "0.9"
 reqwest = { version = "0.12", features = [
-    "json",
-    "stream",
-    "rustls-tls-native-roots",
+  "json",
+  "stream",
+  "rustls-tls-native-roots",
 ], default-features = false, optional = true }
-ringbuf = "0.4"
 serde = "1.0"
 serde_json = "1.0"
 siphasher = "1.0"
@@ -97,38 +79,40 @@ sysinfo = { version = "0.37", default-features = false, features = ["system"] }
 tar = { version = "0.4", optional = true }
 thiserror = { workspace = true }
 tokio = { version = "1.47", features = [
-    "rt",
-    "rt-multi-thread",
-    "parking_lot",
-    "time",
-    "fs",
-    "process",
+  "rt",
+  "rt-multi-thread",
+  "parking_lot",
+  "time",
+  "fs",
+  "process",
 ] }
 tokio-util = { version = "0.7", features = ["io", "io-util"] }
 tokio-stream = "0.1"
 tonic = { workspace = true, features = ["tls-ring", "tls-native-roots"] }
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", default-features = false, features = [
-    "parking_lot",
-    "env-filter",
-    "registry",
-    "ansi",
-] }
 url = "2.5"
 uuid = { version = "1.18", features = ["v4"] }
 # Only need specific features to decompress zip files for ephemeral server download
-zip = { version = "4.6", optional = true, default-features = false, features = ["deflate", "bzip2", "zstd"] }
+zip = { version = "4.6", optional = true, default-features = false, features = [
+  "deflate",
+  "bzip2",
+  "zstd",
+] }
 
 # 1st party local deps
 [dependencies.temporalio-common]
 path = "../common"
-features = ["otel_impls", "history_builders", "test-utilities"]
+version = "0.1"
+features = ["core-based-sdk", "history_builders", "test-utilities"]
 
 [dependencies.temporalio-client]
 path = "../client"
+version = "0.1"
+features = ["core-based-sdk"]
 
 [dependencies.temporalio-macros]
 path = "../macros"
+version = "0.1"
 
 [dev-dependencies]
 assert_matches = "1.5"
@@ -136,19 +120,28 @@ bimap = "0.6.3"
 bytes = "1.10"
 clap = { version = "4.5", features = ["derive"] }
 criterion = { version = "0.7", features = ["async", "async_tokio"] }
+http-body-util = { version = "0.1" }
+hyper = { version = "1.7" }
+hyper-util = { version = "0.1", features = [
+  "server",
+  "http1",
+  "http2",
+  "tokio",
+] }
 rstest = "0.26"
 semver = "1.0"
 temporalio-sdk = { path = "../sdk" }
 tokio = { version = "1.47", features = [
-    "rt",
-    "rt-multi-thread",
-    "parking_lot",
-    "time",
-    "fs",
-    "process",
-    "test-util",
+  "rt",
+  "rt-multi-thread",
+  "parking_lot",
+  "time",
+  "fs",
+  "process",
+  "test-util",
 ] }
 tokio-stream = { version = "0.1", features = ["net"] }
+tracing-subscriber = { version = "0.3", default-features = false }
 trybuild = { version = "1.0", features = ["diff"] }
 
 [[bin]]
@@ -163,9 +156,9 @@ path = "tests/main.rs"
 # `cargo test --test integ_tests`
 test = false
 required-features = [
-    "temporalio-common/serde_serialize",
-    "test-utilities",
-    "ephemeral-server",
+  "temporalio-common/serde_serialize",
+  "test-utilities",
+  "ephemeral-server",
 ]
 
 [[test]]
@@ -213,9 +206,9 @@ path = "tests/runner.rs"
 harness = false
 test = false
 required-features = [
-    "temporalio-common/serde_serialize",
-    "test-utilities",
-    "ephemeral-server",
+  "temporalio-common/serde_serialize",
+  "test-utilities",
+  "ephemeral-server",
 ]
 
 

package/sdk-core/crates/sdk-core/benches/workflow_replay_bench.rs

@@ -7,7 +7,6 @@ use crate::common::{
     DONT_AUTO_INIT_INTEG_TELEM, get_integ_runtime_options, prom_metrics, replay_sdk_worker,
 };
 use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
-use futures_util::StreamExt;
 use std::{
     sync::{Arc, mpsc},
     thread,
@@ -17,7 +16,8 @@ use temporalio_common::{
     protos::{DEFAULT_WORKFLOW_TYPE, canned_histories},
     telemetry::metrics::{MetricKeyValue, MetricParameters, NewAttributes},
 };
-use temporalio_sdk::{WfContext, WorkflowFunction};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{SyncWorkflowContext, WorkflowContext, WorkflowResult};
 use temporalio_sdk_core::{CoreRuntime, replay::HistoryForReplay};
 
 pub fn criterion_benchmark(c: &mut Criterion) {
@@ -30,19 +30,13 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
     let num_timers = 10;
     let t = canned_histories::long_sequential_timers(num_timers as usize);
-    let hist = HistoryForReplay::new(
-        t.get_full_history_info().unwrap().into(),
-        "whatever".to_string(),
-    );
+    let hist = HistoryForReplay::new(t.get_full_history_info().unwrap(), "whatever".to_string());
 
     c.bench_function("Small history replay", |b| {
         b.to_async(&tokio_runtime).iter_batched(
-            || {
-                let func = timers_wf(num_timers);
-                (func, replay_sdk_worker([hist.clone()]))
-            },
-            |(func, mut worker)| async move {
-                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+            || replay_sdk_worker([hist.clone()]),
+            |mut worker| async move {
+                worker.register_workflow_with_factory(move || TimersWf { num_timers });
                 worker.run().await.unwrap();
             },
             BatchSize::SmallInput,
@@ -51,19 +45,16 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
     let num_tasks = 50;
     let t = canned_histories::lots_of_big_signals(num_tasks);
-    let hist = HistoryForReplay::new(
-        t.get_full_history_info().unwrap().into(),
-        "whatever".to_string(),
-    );
+    let hist = HistoryForReplay::new(t.get_full_history_info().unwrap(), "whatever".to_string());
 
     c.bench_function("Large payloads history replay", |b| {
         b.to_async(&tokio_runtime).iter_batched(
-            || {
-                let func = big_signals_wf(num_tasks);
-                (func, replay_sdk_worker([hist.clone()]))
-            },
-            |(func, mut worker)| async move {
-                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+            || replay_sdk_worker([hist.clone()]),
+            |mut worker| async move {
+                worker.register_workflow_with_factory(move || BigSignalsWf {
+                    num_tasks,
+                    signal_count: 0,
+                });
                 worker.run().await.unwrap();
             },
             BatchSize::SmallInput,
@@ -142,24 +133,39 @@ pub fn bench_metrics(c: &mut Criterion) {
 criterion_group!(benches, criterion_benchmark, bench_metrics);
 criterion_main!(benches);
 
-fn timers_wf(num_timers: u32) -> WorkflowFunction {
-    WorkflowFunction::new(move |ctx: WfContext| async move {
-        for _ in 1..=num_timers {
+#[workflow]
+struct TimersWf {
+    num_timers: u32,
+}
+
+#[workflow_methods(factory_only)]
+impl TimersWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        for _ in 1..=ctx.state(|s| s.num_timers) {
             ctx.timer(Duration::from_secs(1)).await;
         }
         Ok(().into())
-    })
+    }
 }
 
-fn big_signals_wf(num_tasks: usize) -> WorkflowFunction {
-    WorkflowFunction::new(move |ctx: WfContext| async move {
-        let mut sigs = ctx.make_signal_channel("bigsig");
-        for _ in 1..=num_tasks {
-            for _ in 1..=5 {
-                let _ = sigs.next().await.unwrap();
-            }
-        }
+#[workflow]
+struct BigSignalsWf {
+    num_tasks: usize,
+    signal_count: usize,
+}
 
+#[workflow_methods(factory_only)]
+impl BigSignalsWf {
+    #[run(name = DEFAULT_WORKFLOW_TYPE)]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let target_count = ctx.state(|s| s.num_tasks * 5);
+        ctx.wait_condition(|s| s.signal_count >= target_count).await;
         Ok(().into())
-    })
+    }
+
+    #[signal(name = "bigsig")]
+    fn handle_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: Vec<u8>) {
+        self.signal_count += 1;
+    }
 }

package/sdk-core/crates/sdk-core/machine_coverage/ActivityMachine_Coverage.puml

@@ -26,7 +26,7 @@ StartedActivityCancelEventRecorded -[#blue]-> TimedOut: ActivityTaskTimedOut
 StartedActivityCancelEventRecorded -[#blue]-> Canceled: ActivityTaskCanceled
 Canceled -[#blue]-> Canceled: ActivityTaskStarted
 Canceled -[#blue]-> Canceled: ActivityTaskCompleted
-TimedOut --> [*]
 Failed --> [*]
+TimedOut --> [*]
 Completed --> [*]
 @enduml

package/sdk-core/crates/sdk-core/src/abstractions.rs

@@ -2,7 +2,7 @@
 
 pub(crate) mod take_cell;
 
-use crate::MetricsContext;
+use crate::{MetricsContext, worker::*};
 use std::{
     fmt::{Debug, Formatter},
     sync::{
@@ -10,13 +10,7 @@ use std::{
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
 };
-use temporalio_common::{
-    telemetry::metrics::TemporalMeter,
-    worker::{
-        SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
-        SlotSupplierPermit, WorkerDeploymentVersion, WorkflowSlotKind,
-    },
-};
+use temporalio_common::{telemetry::metrics::TemporalMeter, worker::WorkerDeploymentVersion};
 use tokio::sync::watch;
 use tokio_util::sync::CancellationToken;
 
@@ -475,9 +469,11 @@ where
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-    use crate::{advance_fut, worker::tuner::FixedSizeSlotSupplier};
+    use crate::{
+        advance_fut,
+        worker::{WorkflowSlotKind, tuner::FixedSizeSlotSupplier},
+    };
     use futures_util::FutureExt;
-    use temporalio_common::worker::WorkflowSlotKind;
 
     pub(crate) fn fixed_size_permit_dealer<SK: SlotKind + Send + Sync + 'static>(
         size: usize,

package/sdk-core/crates/sdk-core/src/core_tests/activity_tasks.rs

@@ -1,12 +1,15 @@
 use crate::{
-    ActivityHeartbeat, Worker, advance_fut, job_assert, prost_dur,
+    ActivityHeartbeat, CompleteActivityError, Worker, advance_fut, job_assert, prost_dur,
     test_help::{
         MockPollCfg, MockWorkerInputs, MocksHolder, QueueResponse, WorkerExt,
         WorkflowCachingPolicy, build_fake_worker, build_mock_pollers, fanout_tasks,
         gen_assert_and_reply, mock_manual_poller, mock_poller, mock_worker, poll_and_reply,
         single_hist_mock_sg, test_worker_cfg,
     },
-    worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
+    worker::{
+        PollerBehavior,
+        client::mocks::{mock_manual_worker_client, mock_worker_client},
+    },
 };
 use futures_util::FutureExt;
 use itertools::Itertools;
@@ -22,8 +25,6 @@ use std::{
     time::{Duration, Instant},
 };
 use temporalio_common::{
-    Worker as WorkerTrait,
-    errors::CompleteActivityError,
     protos::{
         TestHistoryBuilder, canned_histories,
         coresdk::{
@@ -53,7 +54,7 @@ use temporalio_common::{
         },
         test_utils::start_timer_cmd,
     },
-    worker::{PollerBehavior, WorkerTaskTypes},
+    worker::WorkerTaskTypes,
 };
 use tokio::{join, time::sleep};
 use tokio_util::sync::CancellationToken;

package/sdk-core/crates/sdk-core/src/core_tests/mod.rs

@@ -7,28 +7,26 @@ mod workflow_cancels;
 mod workflow_tasks;
 
 use crate::{
-    Worker,
-    errors::PollError,
+    PollError, Worker,
     test_help::{
         MockPollCfg, build_mock_pollers, mock_worker, single_hist_mock_sg, test_worker_cfg,
     },
-    worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
+    worker::{
+        PollerBehavior,
+        client::mocks::{mock_manual_worker_client, mock_worker_client},
+    },
 };
 use futures_util::FutureExt;
 use std::{sync::LazyLock, time::Duration};
-use temporalio_common::{
-    Worker as WorkerTrait,
-    protos::{
-        TestHistoryBuilder, canned_histories,
-        coresdk::{
-            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::{
-            enums::v1::EventType, history::v1::WorkflowExecutionOptionsUpdatedEventAttributes,
-        },
+use temporalio_common::protos::{
+    TestHistoryBuilder, canned_histories,
+    coresdk::{
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{
+        enums::v1::EventType, history::v1::WorkflowExecutionOptionsUpdatedEventAttributes,
     },
-    worker::PollerBehavior,
 };
 use tokio::{sync::Barrier, time::sleep};
 

package/sdk-core/crates/sdk-core/src/core_tests/queries.rs

@@ -4,7 +4,7 @@ use crate::{
         hist_to_poll_resp, mock_worker, single_hist_mock_sg,
     },
     worker::{
-        LEGACY_QUERY_ID,
+        LEGACY_QUERY_ID, WorkerVersioningStrategy,
         client::{LegacyQueryResult, mocks::mock_worker_client},
     },
 };
@@ -13,33 +13,29 @@ use std::{
     collections::{HashMap, VecDeque},
     time::Duration,
 };
-use temporalio_common::{
-    Worker as WorkerTrait,
-    protos::{
-        TestHistoryBuilder, canned_histories,
-        coresdk::{
-            workflow_activation::{
-                WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
-            },
-            workflow_commands::{
-                ActivityCancellationType, CompleteWorkflowExecution,
-                ContinueAsNewWorkflowExecution, QueryResult, RequestCancelActivity, query_result,
-            },
-            workflow_completion::WorkflowActivationCompletion,
+use temporalio_common::protos::{
+    TestHistoryBuilder, canned_histories,
+    coresdk::{
+        workflow_activation::{
+            WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
         },
-        temporal::api::{
-            common::v1::Payload,
-            enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
-            failure::v1::Failure,
-            history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event},
-            query::v1::WorkflowQuery,
-            workflowservice::v1::{
-                GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
-            },
+        workflow_commands::{
+            ActivityCancellationType, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution,
+            QueryResult, RequestCancelActivity, query_result,
+        },
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{
+        common::v1::Payload,
+        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
+        failure::v1::Failure,
+        history::v1::{ActivityTaskCancelRequestedEventAttributes, History, history_event},
+        query::v1::WorkflowQuery,
+        workflowservice::v1::{
+            GetWorkflowExecutionHistoryResponse, RespondWorkflowTaskCompletedResponse,
         },
-        test_utils::{query_ok, schedule_activity_cmd, start_timer_cmd},
     },
-    worker::WorkerVersioningStrategy,
+    test_utils::{query_ok, schedule_activity_cmd, start_timer_cmd},
 };
 
 #[rstest::rstest]

package/sdk-core/crates/sdk-core/src/core_tests/replay_flag.rs

@@ -3,17 +3,14 @@ use crate::{
     worker::{LEGACY_QUERY_ID, client::mocks::mock_worker_client},
 };
 use std::{collections::VecDeque, time::Duration};
-use temporalio_common::{
-    Worker as CoreWorker,
-    protos::{
-        TestHistoryBuilder, canned_histories,
-        coresdk::{
-            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery},
-        test_utils::{query_ok, start_timer_cmd},
+use temporalio_common::protos::{
+    TestHistoryBuilder, canned_histories,
+    coresdk::{
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        workflow_completion::WorkflowActivationCompletion,
     },
+    temporal::api::{enums::v1::EventType, query::v1::WorkflowQuery},
+    test_utils::{query_ok, start_timer_cmd},
 };
 
 #[tokio::test]

package/sdk-core/crates/sdk-core/src/core_tests/updates.rs

@@ -6,24 +6,21 @@ use crate::{
     },
     worker::client::mocks::mock_worker_client,
 };
-use temporalio_common::{
-    Worker,
-    protos::{
-        DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder,
-        coresdk::{
-            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-            workflow_commands::{
-                CompleteWorkflowExecution, ScheduleActivity, StartTimer, UpdateResponse,
-                update_response::Response,
-            },
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::{
-            common::v1::Payload,
-            enums::v1::EventType,
-            update::v1::{Acceptance, Rejection},
-            workflowservice::v1::RespondWorkflowTaskCompletedResponse,
+use temporalio_common::protos::{
+    DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder,
+    coresdk::{
+        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+        workflow_commands::{
+            CompleteWorkflowExecution, ScheduleActivity, StartTimer, UpdateResponse,
+            update_response::Response,
         },
+        workflow_completion::WorkflowActivationCompletion,
+    },
+    temporal::api::{
+        common::v1::Payload,
+        enums::v1::EventType,
+        update::v1::{Acceptance, Rejection},
+        workflowservice::v1::RespondWorkflowTaskCompletedResponse,
     },
 };