@temporalio/core-bridge 1.7.4 → 1.8.1

package/sdk-core/tests/integ_tests/metrics_tests.rs

@@ -1,3 +1,4 @@
+use assert_matches::assert_matches;
 use std::{sync::Arc, time::Duration};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions, WorkflowService};
 use temporal_sdk_core::{init_worker, CoreRuntime};
@@ -5,14 +6,24 @@ use temporal_sdk_core_api::{telemetry::MetricsExporter, worker::WorkerConfigBuil
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
-        workflow_commands::{ScheduleActivity, ScheduleLocalActivity},
+        workflow_activation::{workflow_activation_job, WorkflowActivationJob},
+        workflow_commands::{
+            workflow_command, CancelWorkflowExecution, CompleteWorkflowExecution,
+            ContinueAsNewWorkflowExecution, FailWorkflowExecution, QueryResult, QuerySuccess,
+            ScheduleActivity, ScheduleLocalActivity,
+        },
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion,
     },
-    temporal::api::{enums::v1::WorkflowIdReusePolicy, workflowservice::v1::ListNamespacesRequest},
+    temporal::api::{
+        enums::v1::WorkflowIdReusePolicy, failure::v1::Failure, query::v1::WorkflowQuery,
+        workflowservice::v1::ListNamespacesRequest,
+    },
+};
+use temporal_sdk_core_test_utils::{
+    get_integ_server_options, get_integ_telem_options, CoreWfStarter, NAMESPACE,
 };
-use temporal_sdk_core_test_utils::{get_integ_server_options, get_integ_telem_options, NAMESPACE};
-use tokio::sync::Barrier;
+use tokio::{join, sync::Barrier};
 
 static ANY_PORT: &str = "127.0.0.1:0";
 
@@ -59,10 +70,12 @@ async fn one_slot_worker_reports_available_slot() {
         .namespace(NAMESPACE)
         .task_queue(tq)
         .worker_build_id("test_build_id")
-        .max_cached_workflows(1_usize)
+        .max_cached_workflows(2_usize)
         .max_outstanding_activities(1_usize)
         .max_outstanding_local_activities(1_usize)
-        .max_outstanding_workflow_tasks(1_usize)
+        // Need to use two for WFTs because there are a minimum of 2 pollers b/c of sticky polling
+        .max_outstanding_workflow_tasks(2_usize)
+        .max_concurrent_wft_polls(1_usize)
         .build()
         .unwrap();
 
@@ -146,7 +159,7 @@ async fn one_slot_worker_reports_available_slot() {
         assert!(body.contains(&format!(
             "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
              service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 1"
+             worker_type=\"WorkflowWorker\"}} 2"
         )));
 
         // Start a workflow so that a task will get delivered
@@ -174,7 +187,7 @@ async fn one_slot_worker_reports_available_slot() {
         assert!(body.contains(&format!(
             "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
              service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 0"
+             worker_type=\"WorkflowWorker\"}} 1"
         )));
         assert!(body.contains(&format!(
             "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
@@ -197,7 +210,7 @@ async fn one_slot_worker_reports_available_slot() {
         assert!(body.contains(&format!(
             "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
              service_name=\"temporal-core-sdk\",task_queue=\"one_slot_worker_tq\",\
-             worker_type=\"WorkflowWorker\"}} 1"
+             worker_type=\"WorkflowWorker\"}} 2"
         )));
         assert!(body.contains(&format!(
             "temporal_worker_task_slots_available{{namespace=\"{NAMESPACE}\",\
@@ -235,5 +248,125 @@ async fn one_slot_worker_reports_available_slot() {
              worker_type=\"LocalActivityWorker\"}} 1"
         )));
     };
-    tokio::join!(wf_polling, act_polling, testing);
+    join!(wf_polling, act_polling, testing);
+}
+
+#[rstest::rstest]
+#[tokio::test]
+async fn query_of_closed_workflow_doesnt_tick_terminal_metric(
+    #[values(
+        CompleteWorkflowExecution { result: None }.into(),
+        FailWorkflowExecution {
+            failure: Some(Failure::application_failure("I'm ded".to_string(), false)),
+        }.into(),
+        ContinueAsNewWorkflowExecution::default().into(),
+        CancelWorkflowExecution { }.into()
+    )]
+    completion: workflow_command::Variant,
+) {
+    let mut telemopts = get_integ_telem_options();
+    telemopts.metrics = Some(MetricsExporter::Prometheus(ANY_PORT.parse().unwrap()));
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let addr = rt.telemetry().prom_port().unwrap();
+    let mut starter =
+        CoreWfStarter::new_with_runtime("query_of_closed_workflow_doesnt_tick_terminal_metric", rt);
+    // Disable cache to ensure replay happens completely
+    starter.max_cached_workflows(0);
+    let worker = starter.get_worker().await;
+    let run_id = starter.start_wf().await;
+    let task = worker.poll_workflow_activation().await.unwrap();
+    // Immediately complete the workflow
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            completion.clone(),
+        ))
+        .await
+        .unwrap();
+
+    let metric_name = match &completion {
+        workflow_command::Variant::CompleteWorkflowExecution(_) => "temporal_workflow_completed",
+        workflow_command::Variant::FailWorkflowExecution(_) => "temporal_workflow_failed",
+        workflow_command::Variant::ContinueAsNewWorkflowExecution(_) => {
+            "temporal_workflow_continue_as_new"
+        }
+        workflow_command::Variant::CancelWorkflowExecution(_) => "temporal_workflow_canceled",
+        _ => unreachable!(),
+    };
+
+    // Verify there is one tick for the completion metric
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    let matching_line = body
+        .lines()
+        .find(|l| l.starts_with(metric_name))
+        .expect("Must find matching metric");
+    assert!(matching_line.ends_with('1'));
+
+    // Handle cache eviction
+    let task = worker.poll_workflow_activation().await.unwrap();
+    worker
+        .complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+
+    // Query the now-closed workflow
+    let client = starter.get_client().await;
+    let queryer = async {
+        client
+            .query_workflow_execution(
+                starter.get_wf_id().to_string(),
+                run_id,
+                WorkflowQuery {
+                    query_type: "fake_query".to_string(),
+                    query_args: None,
+                    header: None,
+                },
+            )
+            .await
+            .unwrap();
+    };
+    let query_reply = async {
+        // Need to re-complete b/c replay
+        let task = worker.poll_workflow_activation().await.unwrap();
+        worker
+            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                task.run_id,
+                completion,
+            ))
+            .await
+            .unwrap();
+
+        let task = worker.poll_workflow_activation().await.unwrap();
+        let query = assert_matches!(
+            task.jobs.as_slice(),
+            [WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+            }] => q
+        );
+        worker
+            .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                task.run_id,
+                QueryResult {
+                    query_id: query.query_id.clone(),
+                    variant: Some(
+                        QuerySuccess {
+                            response: Some("hi".into()),
+                        }
+                        .into(),
+                    ),
+                }
+                .into(),
+            ))
+            .await
+            .unwrap()
+    };
+    join!(query_reply, queryer);
+
+    // Verify there is still only one tick
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    let matching_line = body
+        .lines()
+        .find(|l| l.starts_with(metric_name))
+        .expect("Must find matching metric");
+    assert!(matching_line.ends_with('1'));
 }

package/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -17,7 +17,9 @@ use temporal_sdk_core_protos::{
         workflow_activation::{
             workflow_activation_job, FireTimer, ResolveActivity, WorkflowActivationJob,
         },
-        workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
+        workflow_commands::{
+            ActivityCancellationType, RequestCancelActivity, ScheduleActivity, StartTimer,
+        },
         workflow_completion::WorkflowActivationCompletion,
         ActivityHeartbeat, ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
         IntoCompletion,
@@ -728,17 +730,24 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     let activity_id = "act-1";
     let task = core.poll_workflow_activation().await.unwrap();
     // Complete workflow task and schedule activity
-    core.complete_workflow_activation(
-        schedule_activity_cmd(
-            0,
-            &task_q,
-            activity_id,
-            ActivityCancellationType::WaitCancellationCompleted,
-            Duration::from_secs(60),
-            Duration::from_secs(1),
-        )
-        .into_completion(task.run_id),
-    )
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        ScheduleActivity {
+            seq: 0,
+            activity_id: activity_id.to_string(),
+            activity_type: "dontcare".to_string(),
+            task_queue: task_q.clone(),
+            schedule_to_close_timeout: Some(prost_dur!(from_secs(10))),
+            heartbeat_timeout: Some(prost_dur!(from_secs(1))),
+            retry_policy: Some(RetryPolicy {
+                maximum_attempts: 2,
+                initial_interval: Some(prost_dur!(from_secs(5))),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }
+        .into(),
+    ))
     .await
     .unwrap();
     // Poll activity and verify that it's been scheduled
@@ -753,8 +762,8 @@ async fn activity_cancelled_after_heartbeat_times_out() {
 
     // Verify activity got cancelled
     let cancel_task = core.poll_activity_task().await.unwrap();
-    assert_eq!(cancel_task.task_token, task.task_token.clone());
     assert_matches!(cancel_task.variant, Some(act_task::Variant::Cancel(_)));
+    assert_eq!(cancel_task.task_token, task.task_token.clone());
 
     // Complete activity with cancelled result
     core.complete_activity_task(ActivityTaskCompletion {
@@ -770,7 +779,7 @@ async fn activity_cancelled_after_heartbeat_times_out() {
     starter
         .get_client()
         .await
-        .terminate_workflow_execution(task_q.clone(), None)
+        .terminate_workflow_execution(task_q, None)
         .await
         .unwrap();
 }
@@ -905,7 +914,9 @@ async fn it_can_complete_async() {
 async fn graceful_shutdown() {
     let wf_name = "graceful_shutdown";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.graceful_shutdown_period = Some(Duration::from_millis(500));
+    starter
+        .worker_config
+        .graceful_shutdown_period(Some(Duration::from_millis(500)));
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {

package/sdk-core/tests/integ_tests/workflow_tests/child_workflows.rs

@@ -91,7 +91,7 @@ async fn abandoned_child_bug_repro() {
     );
     worker.register_wf(CHILD_WF_TYPE.to_string(), |mut ctx: WfContext| async move {
         ctx.cancelled().await;
-        Ok(WfExitValue::Cancelled)
+        Ok(WfExitValue::<()>::Cancelled)
     });
 
     worker

package/sdk-core/tests/integ_tests/workflow_tests/continue_as_new.rs

@@ -43,8 +43,8 @@ async fn continue_as_new_multiple_concurrent() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .no_remote_activities()
-        .max_cached_workflows(3)
-        .max_wft(3);
+        .max_cached_workflows(5)
+        .max_wft(5);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_string(), continue_as_new_wf);
 

package/sdk-core/tests/integ_tests/workflow_tests/stickyness.rs

@@ -55,7 +55,11 @@ async fn timer_workflow_timeout_on_sticky() {
 async fn cache_miss_ok() {
     let wf_name = "cache_miss_ok";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities().max_wft(1);
+    starter
+        .no_remote_activities()
+        .max_wft(2)
+        .max_cached_workflows(0);
+    starter.worker_config.max_concurrent_wft_polls(1_usize);
     let mut worker = starter.worker().await;
 
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -434,6 +434,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0)
         .max_wft(1);
+    wf_starter.worker_config.max_concurrent_wft_polls(1_usize);
     wf_starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
     let client = wf_starter.get_client().await;

package/src/conversions.rs

@@ -294,6 +294,10 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             js_value_getter!(cx, self, "maxConcurrentLocalActivityExecutions", JsNumber) as usize;
         let max_outstanding_workflow_tasks =
             js_value_getter!(cx, self, "maxConcurrentWorkflowTaskExecutions", JsNumber) as usize;
+        let max_concurrent_wft_polls =
+            js_value_getter!(cx, self, "maxConcurrentWorkflowTaskPolls", JsNumber) as usize;
+        let max_concurrent_at_polls =
+            js_value_getter!(cx, self, "maxConcurrentActivityTaskPolls", JsNumber) as usize;
         let sticky_queue_schedule_to_start_timeout = Duration::from_millis(js_value_getter!(
             cx,
             self,
@@ -319,10 +323,10 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
         let max_worker_activities_per_second =
             js_optional_getter!(cx, self, "maxActivitiesPerSecond", JsNumber)
-                .map(|num| num.value(cx) as f64);
+                .map(|num| num.value(cx));
         let max_task_queue_activities_per_second =
             js_optional_getter!(cx, self, "maxTaskQueueActivitiesPerSecond", JsNumber)
-                .map(|num| num.value(cx) as f64);
+                .map(|num| num.value(cx));
 
         let graceful_shutdown_period =
             js_optional_getter!(cx, self, "shutdownGraceTimeMs", JsNumber)
@@ -331,10 +335,13 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         match WorkerConfigBuilder::default()
             .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
             .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
+            .use_worker_versioning(js_value_getter!(cx, self, "useVersioning", JsBoolean))
             .no_remote_activities(!enable_remote_activities)
             .max_outstanding_workflow_tasks(max_outstanding_workflow_tasks)
             .max_outstanding_activities(max_outstanding_activities)
             .max_outstanding_local_activities(max_outstanding_local_activities)
+            .max_concurrent_wft_polls(max_concurrent_wft_polls)
+            .max_concurrent_at_polls(max_concurrent_at_polls)
             .max_cached_workflows(max_cached_workflows)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
             .graceful_shutdown_period(graceful_shutdown_period)

package/src/runtime.rs

@@ -120,8 +120,9 @@ pub fn start_bridge_loop(
 ) {
     let mut tokio_builder = tokio::runtime::Builder::new_multi_thread();
     tokio_builder.enable_all().thread_name("core");
-    let core_runtime =
-        CoreRuntime::new(telemetry_options, tokio_builder).expect("Failed to create CoreRuntime");
+    let core_runtime = Arc::new(
+        CoreRuntime::new(telemetry_options, tokio_builder).expect("Failed to create CoreRuntime"),
+    );
 
     core_runtime.tokio_handle().block_on(async {
         loop {
@@ -144,14 +145,11 @@ pub fn start_bridge_loop(
                     headers,
                     callback,
                 } => {
-                    // `metrics_meter` can be None here since we don't use the returned client
-                    // directly at the moment, when we repurpose the client to be used by a Worker,
-                    // `init_worker` will attach the correct metrics meter for us.
+                    let runtime_clone = core_runtime.clone();
                     core_runtime.tokio_handle().spawn(async move {
-                        let metrics_meter = None;
                         match options
                             .connect_no_namespace(
-                                metrics_meter,
+                                runtime_clone.metric_meter().as_deref(),
                                 headers.map(|h| Arc::new(RwLock::new(h))),
                             )
                             .await

package/ts/errors.ts

@@ -1,10 +1,24 @@
 import { IllegalStateError } from '@temporalio/common';
 
+const isShutdownError: unique symbol = Symbol.for('__temporal_isShutdownError');
+
 /**
  * The worker has been shut down
  */
 export class ShutdownError extends Error {
   public readonly name = 'ShutdownError';
+
+  /**
+   * Marker to determine whether an error is an instance of TerminatedFailure.
+   */
+  protected readonly [isShutdownError] = true;
+
+  /**
+   * Instanceof check that works when multiple versions of @temporalio/core-bridge are installed.
+   */
+  static is(error: unknown): error is ShutdownError {
+    return error instanceof ShutdownError || (error as any)?.[isShutdownError] === true;
+  }
 }
 
 /**
@@ -21,6 +35,7 @@ export class TransportError extends Error {
 export class UnexpectedError extends Error {
   public readonly name = 'UnexpectedError';
 }
+
 export { IllegalStateError };
 
 export function convertFromNamedError(e: unknown, keepStackTrace: boolean): unknown {

package/ts/index.ts

@@ -1,8 +1,12 @@
 import { SpanContext } from '@opentelemetry/api';
+import { LogLevel, Duration } from '@temporalio/common';
 import type { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
 
 export { TLSConfig };
 
+/** @deprecated Import from @temporalio/common instead */
+export { LogLevel };
+
 type Shadow<Base, New> = Base extends object
   ? New extends object
     ? {
@@ -118,7 +122,7 @@ export interface OtelCollectorExporter {
      * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
      * @defaults 1 second
      */
-    metricsExportInterval?: string | number;
+    metricsExportInterval?: Duration;
   };
 }
 
@@ -266,6 +270,13 @@ export interface WorkerOptions {
    * A string that should be unique to the exact worker code/binary being executed
    */
   buildId: string;
+  /**
+   * If set true, this worker opts into the worker versioning feature. This ensures it only receives
+   * workflow tasks for workflows which it claims to be compatible with.
+   *
+   * For more information, see https://docs.temporal.io/workers#worker-versioning
+   */
+  useVersioning: boolean;
 
   /**
    * The task queue the worker will pull from
@@ -276,6 +287,16 @@ export interface WorkerOptions {
   maxConcurrentWorkflowTaskExecutions: number;
   maxConcurrentLocalActivityExecutions: number;
 
+  /**
+   * Maximum number of Workflow tasks to poll concurrently.
+   */
+  maxConcurrentWorkflowTaskPolls: number;
+
+  /**
+   * Maximum number of Activity tasks to poll concurrently.
+   */
+  maxConcurrentActivityTaskPolls: number;
+
   /**
    * If set to `false` this worker will only handle workflow tasks and local activities, it will not
    * poll for activity tasks.
@@ -323,9 +344,6 @@ export interface WorkerOptions {
   maxActivitiesPerSecond?: number;
 }
 
-/** Log level - must match rust log level names */
-export type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
-
 export interface LogEntry {
   /** Log message */
   message: string;