@temporalio/core-bridge 1.7.1 → 1.7.3

package/Cargo.lock

@@ -517,6 +517,26 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "enum-iterator"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "706d9e7cf1c7664859d79cd524e4e53ea2b67ea03c98cc2870c5e539695d597e"
+dependencies = [
+ "enum-iterator-derive",
+]
+
+[[package]]
+name = "enum-iterator-derive"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "355f93763ef7b0ae1c43c4d8eccc9d5848d84ad1a1d8ce61c421d1ac85a19d05"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "enum_dispatch"
 version = "0.3.11"
@@ -2272,6 +2292,7 @@ dependencies = [
  "dashmap",
  "derive_builder",
  "derive_more",
+ "enum-iterator",
  "enum_dispatch",
  "flate2",
  "futures",

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 import { SpanContext } from '@opentelemetry/api';
 import type { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
 export { TLSConfig };
-declare type Shadow<Base, New> = Base extends object ? New extends object ? {
+type Shadow<Base, New> = Base extends object ? New extends object ? {
     [K in keyof Base | keyof New]: K extends keyof Base ? K extends keyof New ? Shadow<Base[K], New[K]> : Base[K] : K extends keyof New ? New[K] : never;
 } : New : New;
 export interface RetryOptions {
@@ -74,7 +74,7 @@ export interface ForwardLogger {
  *
  * @experimental
  */
-export declare type Logger = ConsoleLogger | ForwardLogger;
+export type Logger = ConsoleLogger | ForwardLogger;
 /**
  * OpenTelemetry Collector options for exporting metrics or traces
  *
@@ -100,13 +100,13 @@ export interface OtelCollectorExporter {
     };
 }
 /** @experimental */
-export declare type CompiledOtelTraceExporter = Shadow<OtelCollectorExporter, {
+export type CompiledOtelTraceExporter = Shadow<OtelCollectorExporter, {
     otel: {
         metricsExportInterval?: never;
     };
 }>;
 /** @experimental */
-export declare type CompiledOtelMetricsExporter = Shadow<OtelCollectorExporter, {
+export type CompiledOtelMetricsExporter = Shadow<OtelCollectorExporter, {
     otel: {
         metricsExportInterval: number;
     };
@@ -136,7 +136,7 @@ export interface PrometheusMetricsExporter {
  *
  * @experimental
  */
-export declare type MetricsExporter = {
+export type MetricsExporter = {
     temporality?: 'cumulative' | 'delta';
 } & (PrometheusMetricsExporter | OtelCollectorExporter);
 /**
@@ -144,7 +144,7 @@ export declare type MetricsExporter = {
  *
  * @experimental
  */
-export declare type TraceExporter = OtelCollectorExporter;
+export type TraceExporter = OtelCollectorExporter;
 /** @experimental */
 export interface TelemetryOptions {
     /**
@@ -216,7 +216,7 @@ export interface TelemetryOptions {
     metrics?: MetricsExporter;
 }
 /** @experimental */
-export declare type CompiledTelemetryOptions = {
+export type CompiledTelemetryOptions = {
     noTemporalPrefixForMetrics?: boolean;
     logging: {
         filter: string;
@@ -290,7 +290,7 @@ export interface WorkerOptions {
     maxActivitiesPerSecond?: number;
 }
 /** Log level - must match rust log level names */
-export declare type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 export interface LogEntry {
     /** Log message */
     message: string;
@@ -306,7 +306,7 @@ export interface LogEntry {
 /**
  * Which version of the executable to run.
  */
-export declare type EphemeralServerExecutable = {
+export type EphemeralServerExecutable = {
     type: 'cached-download';
     /**
      * Download destination directory or the system's temp directory if none set.
@@ -390,7 +390,7 @@ export interface DevServerConfig {
  *
  * Both the time-skipping test server and Temporal CLI dev server are supported.
  */
-export declare type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
+export type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
 export interface Worker {
     type: 'Worker';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -22,8 +22,8 @@
   "author": "Temporal Technologies Inc. <sdk@temporal.io>",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.3.0",
-    "@temporalio/common": "1.7.1",
+    "@opentelemetry/api": "^1.4.1",
+    "@temporalio/common": "1.7.3",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "368aa83c631555fc31cff25f4af8817d069878d8"
+  "gitHead": "c78237bad40342b97a0aaec97ef01763b39a04f8"
 }

package/sdk-core/.buildkite/pipeline.yml

@@ -17,7 +17,7 @@ steps:
     agents:
       queue: "default"
       docker: "*"
-    command: "cargo lint"
+    command: "cargo lint && cargo test-lint"
     timeout_in_minutes: 15
     plugins:
       - docker-compose#v3.0.0:

package/sdk-core/.cargo/config.toml

@@ -4,3 +4,5 @@ wf-input-replay = ["run", "--package", "temporal-sdk-core", "--features", "save_
                    "--example", "wf_input_replay", "--"]
 lint = ["clippy", "--workspace", "--examples", "--all-features",
         "--test", "integ_tests", "--test", "heavy_tests", "--", "--D", "warnings"]
+test-lint = ["clippy", "--all", "--all-features", "--examples", "--workspace",
+             "--tests", "--", "--D", "warnings"]

package/sdk-core/CODEOWNERS

@@ -1,3 +1,3 @@
 # Primary owners
 
-* @Sushisource @bergundy @cretz @Spikhalskiy
+* @temporalio/sdk

package/sdk-core/client/src/raw.rs

@@ -740,9 +740,9 @@ proxier! {
         }
     );
     (
-        update_worker_build_id_ordering,
-        UpdateWorkerBuildIdOrderingRequest,
-        UpdateWorkerBuildIdOrderingResponse,
+        update_worker_build_id_compatibility,
+        UpdateWorkerBuildIdCompatibilityRequest,
+        UpdateWorkerBuildIdCompatibilityResponse,
         |r| {
             let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
             labels.task_q_str(r.get_ref().task_queue.clone());
@@ -750,9 +750,9 @@ proxier! {
         }
     );
     (
-        get_worker_build_id_ordering,
-        GetWorkerBuildIdOrderingRequest,
-        GetWorkerBuildIdOrderingResponse,
+        get_worker_build_id_compatibility,
+        GetWorkerBuildIdCompatibilityRequest,
+        GetWorkerBuildIdCompatibilityResponse,
         |r| {
             let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
             labels.task_q_str(r.get_ref().task_queue.clone());
@@ -768,6 +768,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        poll_workflow_execution_update,
+        PollWorkflowExecutionUpdateRequest,
+        PollWorkflowExecutionUpdateResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         start_batch_operation,
         StartBatchOperationRequest,

package/sdk-core/core/Cargo.toml

@@ -28,6 +28,7 @@ dashmap = "5.0"
 derive_builder = "0.12"
 derive_more = "0.99"
 enum_dispatch = "0.3"
+enum-iterator = "1.4"
 flate2 = "1.0"
 futures = "0.3"
 futures-util = "0.3"

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

@@ -58,7 +58,7 @@ use temporal_sdk_core_protos::{
     TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, TestWorker};
-use tokio::{sync::Barrier, time::sleep};
+use tokio::{join, sync::Barrier, time::sleep};
 use tokio_util::sync::CancellationToken;
 
 fn three_tasks() -> VecDeque<PollActivityTaskQueueResponse> {
@@ -288,7 +288,7 @@ async fn activity_cancel_interrupts_poll() {
     // Perform first poll to get the activity registered
     let act = core.poll_activity_task().await.unwrap();
     // Poll should block until heartbeat is sent, issuing the cancel, and interrupting the poll
-    tokio::join! {
+    join! {
         async {
             core.record_activity_heartbeat(ActivityHeartbeat {
                 task_token: act.task_token,
@@ -984,7 +984,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
     // This wf poll should *not* set the flag that it wants tasks back since both slots are
     // occupied
     let run_fut = async { worker.run_until_done().await.unwrap() };
-    tokio::join!(run_fut, act_completer);
+    join!(run_fut, act_completer);
 }
 
 #[tokio::test]
@@ -1052,9 +1052,11 @@ async fn cant_complete_activity_with_unset_result_payload() {
     )
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn graceful_shutdown() {
+async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
     let _task_q = "q";
+    let grace_period = Duration::from_millis(200);
     let mut tasks = three_tasks();
     let mut mock_client = mock_workflow_client();
     mock_client
@@ -1067,15 +1069,21 @@ async fn graceful_shutdown() {
         .times(3)
         .returning(|_, _| Ok(Default::default()));
 
+    let max_outstanding = if at_max_outstanding { 3_usize } else { 100 };
     let worker = Worker::new_test(
         test_worker_cfg()
-            .graceful_shutdown_period(Duration::from_millis(500))
+            .graceful_shutdown_period(grace_period)
+            .max_outstanding_activities(max_outstanding)
             .build()
             .unwrap(),
         mock_client,
     );
 
     let _1 = worker.poll_activity_task().await.unwrap();
+
+    // Wait at least the grace period after one poll - ensuring it doesn't trigger prematurely
+    tokio::time::sleep(grace_period.mul_f32(1.1)).await;
+
     let _2 = worker.poll_activity_task().await.unwrap();
     let _3 = worker.poll_activity_task().await.unwrap();
 

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -1,5 +1,7 @@
 use crate::{
-    advance_fut, job_assert,
+    advance_fut,
+    internal_flags::CoreInternalFlags,
+    job_assert,
     replay::TestHistoryBuilder,
     test_help::{
         build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories,
@@ -14,9 +16,9 @@ use crate::{
 use futures::{stream, FutureExt};
 use rstest::{fixture, rstest};
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::{HashMap, HashSet, VecDeque},
     sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering},
+        atomic::{AtomicU64, Ordering},
         Arc,
     },
     time::Duration,
@@ -54,9 +56,7 @@ use temporal_sdk_core_protos::{
     },
     DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
 };
-use temporal_sdk_core_test_utils::{
-    fanout_tasks, schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers,
-};
+use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, WorkerTestHelpers};
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
@@ -896,10 +896,7 @@ async fn workflow_failures_only_reported_once() {
 #[tokio::test]
 async fn max_wft_respected() {
     let total_wfs = 100;
-    let wf_ids: Vec<_> = (0..total_wfs)
-        .into_iter()
-        .map(|i| format!("fake-wf-{i}"))
-        .collect();
+    let wf_ids: Vec<_> = (0..total_wfs).map(|i| format!("fake-wf-{i}")).collect();
     let hists = wf_ids.iter().map(|wf_id| {
         let hist = canned_histories::single_timer("1");
         FakeWfResponses {
@@ -1027,7 +1024,7 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static
 #[tokio::test]
 async fn lots_of_workflows() {
     let total_wfs = 500;
-    let hists = (0..total_wfs).into_iter().map(|i| {
+    let hists = (0..total_wfs).map(|i| {
         let wf_id = format!("fake-wf-{i}");
         let hist = canned_histories::single_timer("1");
         FakeWfResponses {
@@ -1705,9 +1702,7 @@ async fn pagination_works_with_tasks_from_completion() {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
     t.add_we_signaled("sig", vec![]);
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
-    let get_exec_resp: GetWorkflowExecutionHistoryResponse = t.get_history_info(2).unwrap().into();
+    t.add_workflow_task_scheduled_and_started();
 
     let mut mock = mock_workflow_client();
     let mut needs_pag_resp = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(2)).resp;
@@ -1722,9 +1717,13 @@ async fn pagination_works_with_tasks_from_completion() {
     mock.expect_complete_workflow_task()
         .times(1)
         .returning(|_| Ok(Default::default()));
+
+    let get_exec_resp: GetWorkflowExecutionHistoryResponse =
+        t.get_full_history_info().unwrap().into();
     mock.expect_get_workflow_execution_history()
         .returning(move |_, _, _| Ok(get_exec_resp.clone()))
         .times(1);
+
     let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
@@ -2162,10 +2161,6 @@ async fn fetching_to_continue_replay_works() {
     t.add_full_wf_task(); // end 14
     let mut fetch_resp: GetWorkflowExecutionHistoryResponse =
         t.get_full_history_info().unwrap().into();
-    // Should only contain events after 7
-    if let Some(ref mut h) = fetch_resp.history {
-        h.events.retain(|e| e.event_id >= 8);
-    }
     // And indicate that even *more* needs to be fetched after this, so we see a request for the
     // next page happen.
     fetch_resp.next_page_token = vec![2];
@@ -2173,12 +2168,8 @@ async fn fetching_to_continue_replay_works() {
     let timer_started_event_id = t.add_by_type(EventType::TimerStarted);
     t.add_timer_fired(timer_started_event_id, "1".to_string());
     t.add_full_wf_task();
-    let mut final_fetch_resp: GetWorkflowExecutionHistoryResponse =
+    let final_fetch_resp: GetWorkflowExecutionHistoryResponse =
         t.get_full_history_info().unwrap().into();
-    // Should have only the final event
-    if let Some(ref mut h) = final_fetch_resp.history {
-        h.events.retain(|e| e.event_id >= 15);
-    }
 
     let tasks = vec![
         ResponseType::ToTaskNum(1),
@@ -2273,15 +2264,25 @@ async fn ensure_fetching_fail_during_complete_sends_task_failure() {
     t.add_full_wf_task(); // started 3
     t.add_we_signaled("sig1", vec![]);
     t.add_full_wf_task(); // started 7
-    t.add_we_signaled("sig2", vec![]);
+
+    // Need a command event after here so the paginator will know it has two complete WFTs and
+    // processing can begin before needing to fetch again
+    t.add_by_type(EventType::TimerStarted);
     t.add_full_wf_task(); // started 11
     t.add_workflow_execution_completed();
 
-    let mut first_poll = hist_to_poll_resp(&t, wfid, ResponseType::ToTaskNum(1)).resp;
-    first_poll.next_page_token = vec![1];
-    first_poll.previous_started_event_id = 3;
+    let mut first_poll = hist_to_poll_resp(&t, wfid, ResponseType::OneTask(4)).resp;
+    // History is partial so fetch will happen. We have to lie here and make up a previous started
+    // which really makes no sense, otherwise the paginator eagerly fetches and will fail before we
+    // ever start anything -- which is good -- but this test wants to make sure a fetching failure
+    // during a completion is handled correctly. That may no longer actually be a thing that can
+    // happen.
+    first_poll.previous_started_event_id = 0;
+    first_poll.started_event_id = 11;
 
-    let mut next_page: GetWorkflowExecutionHistoryResponse = t.get_history_info(2).unwrap().into();
+    let mut next_page: GetWorkflowExecutionHistoryResponse =
+        t.get_full_history_info().unwrap().into();
+    next_page.history.as_mut().unwrap().events.truncate(9);
     next_page.next_page_token = vec![2];
 
     let mut mock = mock_workflow_client();
@@ -2291,13 +2292,10 @@ async fn ensure_fetching_fail_during_complete_sends_task_failure() {
             Ok(next_page.clone())
         })
         .times(1);
-    let mut really_empty_fetch_resp: GetWorkflowExecutionHistoryResponse =
-        t.get_history_info(1).unwrap().into();
-    really_empty_fetch_resp.history = Some(Default::default());
     mock.expect_get_workflow_execution_history()
         .returning(move |_, _, _| {
             error!("Called fetch second time!");
-            Ok(really_empty_fetch_resp.clone())
+            Err(tonic::Status::not_found("Ahh broken"))
         })
         .times(1);
     mock.expect_fail_workflow_task()
@@ -2314,24 +2312,13 @@ async fn ensure_fetching_fail_during_complete_sends_task_failure() {
         .await
         .unwrap();
 
-    let wf_task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        wf_task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-        },]
-    );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
-        .await
-        .unwrap();
-
     // Expect to see eviction b/c of history fetching error here.
     let wf_task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         wf_task.jobs.as_slice(),
         [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-        },]
+            variant: Some(workflow_activation_job::Variant::RemoveFromCache(c)),
+        }] if c.message.contains("Fetching history")
     );
 
     core.shutdown().await;
@@ -2380,54 +2367,35 @@ async fn lang_internal_flags() {
     core.shutdown().await;
 }
 
-// Verify we send flags to server when they're used
+// Verify we send all core internal flags on the first non-replay WFT
 #[tokio::test]
 async fn core_internal_flags() {
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let act_scheduled_event_id = t.add_activity_task_scheduled("act-id");
-    let act_started_event_id = t.add_activity_task_started(act_scheduled_event_id);
-    t.add_activity_task_completed(
-        act_scheduled_event_id,
-        act_started_event_id,
-        Default::default(),
-    );
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
+    t.add_workflow_task_scheduled_and_started();
 
     let mut mh = MockPollCfg::from_resp_batches(
         "fake_wf_id",
         t,
-        [ResponseType::ToTaskNum(1), ResponseType::ToTaskNum(2)],
+        [ResponseType::ToTaskNum(1)],
         mock_workflow_client(),
     );
-    let first_poll = AtomicBool::new(true);
     mh.completion_asserts = Some(Box::new(move |c| {
-        if !first_poll.load(Ordering::Acquire) {
-            assert_matches!(c.sdk_metadata.core_used_flags.as_slice(), &[1]);
-        }
-        first_poll.store(false, Ordering::Release);
+        assert_eq!(
+            c.sdk_metadata
+                .core_used_flags
+                .iter()
+                .copied()
+                .collect::<HashSet<_>>(),
+            CoreInternalFlags::all_except_too_high()
+                .map(|f| f as u32)
+                .collect()
+        );
     }));
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
     let core = mock_worker(mock);
 
-    let act = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        act.run_id,
-        schedule_activity_cmd(
-            1,
-            "whatever",
-            "act-id",
-            ActivityCancellationType::TryCancel,
-            Duration::from_secs(60),
-            Duration::from_secs(60),
-        ),
-    ))
-    .await
-    .unwrap();
-
     let act = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&act.run_id).await;
     core.shutdown().await;