@temporalio/core-bridge 1.12.0 → 1.12.2

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

@@ -1,7 +1,13 @@
 use crate::integ_tests::mk_nexus_endpoint;
 use anyhow::anyhow;
 use assert_matches::assert_matches;
-use std::{collections::HashMap, env, string::ToString, sync::Arc, time::Duration};
+use std::{
+    collections::HashMap,
+    env,
+    string::ToString,
+    sync::{Arc, OnceLock},
+    time::Duration,
+};
 use temporal_client::{
     REQUEST_LATENCY_HISTOGRAM_NAME, WorkflowClientTrait, WorkflowOptions, WorkflowService,
 };
@@ -19,7 +25,10 @@ use temporal_sdk_core_api::{
     telemetry::{
         HistogramBucketOverrides, OtelCollectorOptionsBuilder, OtlpProtocol,
         PrometheusExporterOptionsBuilder, TelemetryOptionsBuilder,
-        metrics::{CoreMeter, MetricAttributes, MetricParameters},
+        metrics::{
+            CoreMeter, CounterBase, Gauge, GaugeBase, HistogramBase, MetricKeyValue,
+            MetricParameters, MetricParametersBuilder, NewAttributes,
+        },
     },
     worker::{
         PollerBehavior, SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
@@ -72,6 +81,7 @@ async fn prometheus_metrics_exported(
 ) {
     let mut opts_builder = PrometheusExporterOptionsBuilder::default();
     opts_builder
+        .global_tags(HashMap::from([("global".to_string(), "hi!".to_string())]))
         .socket_addr(ANY_PORT.parse().unwrap())
         .use_seconds_for_durations(use_seconds_latency);
     if custom_buckets {
@@ -99,25 +109,25 @@ async fn prometheus_metrics_exported(
 
     let body = get_text(format!("http://{addr}/metrics")).await;
     assert!(body.contains(
-        "temporal_request_latency_count{operation=\"ListNamespaces\",service_name=\"temporal-core-sdk\"} 1"
+        "temporal_request_latency_count{operation=\"ListNamespaces\",service_name=\"temporal-core-sdk\",global=\"hi!\"} 1"
     ));
     assert!(body.contains(
-        "temporal_request_latency_count{operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\"} 1"
+        "temporal_request_latency_count{operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",global=\"hi!\"} 1"
     ));
     if custom_buckets {
         assert!(body.contains(
             "temporal_request_latency_bucket{\
-             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",le=\"1337\"}"
+             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",global=\"hi!\",le=\"1337\"}"
         ));
     } else if use_seconds_latency {
         assert!(body.contains(
             "temporal_request_latency_bucket{\
-             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",le=\"0.05\"}"
+             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",global=\"hi!\",le=\"0.05\"}"
         ));
     } else {
         assert!(body.contains(
             "temporal_request_latency_bucket{\
-             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",le=\"50\"}"
+             operation=\"GetSystemInfo\",service_name=\"temporal-core-sdk\",global=\"hi!\",le=\"50\"}"
         ));
     }
     // Verify counter names are appropriate (don't end w/ '_total')
@@ -125,15 +135,10 @@ async fn prometheus_metrics_exported(
     // Verify non-temporal metrics meter does not prefix
     let mm = rt.telemetry().get_metric_meter().unwrap();
     let g = mm.inner.gauge(MetricParameters::from("mygauge"));
-    g.record(
-        42,
-        &MetricAttributes::OTel {
-            kvs: Arc::new(vec![]),
-        },
-    );
+    let attrs = mm.inner.new_attributes(NewAttributes::new(vec![]));
+    g.record(42, &attrs);
     let body = get_text(format!("http://{addr}/metrics")).await;
-    println!("{}", &body);
-    assert!(body.contains("\nmygauge 42"));
+    assert!(body.contains("\nmygauge{global=\"hi!\"} 42"));
 }
 
 #[tokio::test]
@@ -688,7 +693,7 @@ async fn docker_metrics_with_prometheus(
     )]
     otel_collector: (&str, OtlpProtocol),
 ) {
-    if std::env::var("DOCKER_PROMETHEUS_RUNNING").is_err() {
+    if env::var("DOCKER_PROMETHEUS_RUNNING").is_err() {
         return;
     }
     let (otel_collector_addr, otel_protocol) = otel_collector;
@@ -730,7 +735,7 @@ async fn docker_metrics_with_prometheus(
     client.list_namespaces().await.unwrap();
 
     // Give Prometheus time to scrape metrics
-    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+    tokio::time::sleep(Duration::from_secs(2)).await;
 
     // Query Prometheus API for metrics
     let client = reqwest::Client::new();
@@ -767,6 +772,9 @@ async fn activity_metrics() {
     let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
     let wf_name = "activity_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
+    starter
+        .worker_config
+        .graceful_shutdown_period(Duration::from_secs(1));
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
@@ -777,11 +785,6 @@ async fn activity_metrics() {
             start_to_close_timeout: Some(Duration::from_secs(1)),
             ..Default::default()
         });
-        let local_act_pass = ctx.local_activity(LocalActivityOptions {
-            activity_type: "pass_fail_act".to_string(),
-            input: "pass".as_json_payload().expect("serializes fine"),
-            ..Default::default()
-        });
         let normal_act_fail = ctx.activity(ActivityOptions {
             activity_type: "pass_fail_act".to_string(),
             input: "fail".as_json_payload().expect("serializes fine"),
@@ -792,6 +795,12 @@ async fn activity_metrics() {
             }),
             ..Default::default()
         });
+        join!(normal_act_pass, normal_act_fail);
+        let local_act_pass = ctx.local_activity(LocalActivityOptions {
+            activity_type: "pass_fail_act".to_string(),
+            input: "pass".as_json_payload().expect("serializes fine"),
+            ..Default::default()
+        });
         let local_act_fail = ctx.local_activity(LocalActivityOptions {
             activity_type: "pass_fail_act".to_string(),
             input: "fail".as_json_payload().expect("serializes fine"),
@@ -810,12 +819,8 @@ async fn activity_metrics() {
             },
             ..Default::default()
         });
-        join!(
-            normal_act_pass,
-            local_act_pass,
-            normal_act_fail,
-            local_act_fail
-        );
+        join!(local_act_pass, local_act_fail);
+        // TODO: Currently takes a WFT b/c of https://github.com/temporalio/sdk-core/issues/856
         local_act_cancel.cancel(&ctx);
         local_act_cancel.await;
         Ok(().into())
@@ -824,7 +829,6 @@ async fn activity_metrics() {
         match i.as_str() {
             "pass" => Ok("pass"),
             "cancel" => {
-                // TODO: Cancel is taking until shutdown to come through :|
                 ctx.cancelled().await;
                 Err(ActivityError::cancelled())
             }
@@ -925,35 +929,29 @@ async fn nexus_metrics() {
                         .await
                 },
                 async {
-                    ctx.start_nexus_operation(NexusOperationOptions {
-                        input: Some("fail".into()),
-                        ..partial_op.clone()
-                    })
-                    .await
-                    .unwrap()
-                    .result()
-                    .await
+                    let _ = ctx
+                        .start_nexus_operation(NexusOperationOptions {
+                            input: Some("fail".into()),
+                            ..partial_op.clone()
+                        })
+                        .await;
                 },
                 async {
-                    ctx.start_nexus_operation(NexusOperationOptions {
-                        input: Some("handler-fail".into()),
-                        ..partial_op.clone()
-                    })
-                    .await
-                    .unwrap()
-                    .result()
-                    .await
+                    let _ = ctx
+                        .start_nexus_operation(NexusOperationOptions {
+                            input: Some("handler-fail".into()),
+                            ..partial_op.clone()
+                        })
+                        .await;
                 },
                 async {
-                    ctx.start_nexus_operation(NexusOperationOptions {
-                        input: Some("timeout".into()),
-                        schedule_to_close_timeout: Some(Duration::from_secs(2)),
-                        ..partial_op.clone()
-                    })
-                    .await
-                    .unwrap()
-                    .result()
-                    .await
+                    let _ = ctx
+                        .start_nexus_operation(NexusOperationOptions {
+                            input: Some("timeout".into()),
+                            schedule_to_close_timeout: Some(Duration::from_secs(2)),
+                            ..partial_op.clone()
+                        })
+                        .await;
                 }
             );
             Ok(().into())
@@ -1111,6 +1109,7 @@ async fn evict_on_complete_does_not_count_as_forced_eviction() {
 
 struct MetricRecordingSlotSupplier<SK> {
     inner: FixedSizeSlotSupplier<SK>,
+    metrics: OnceLock<(Gauge, Gauge, Gauge)>,
 }
 
 #[async_trait::async_trait]
@@ -1121,16 +1120,18 @@ where
     type SlotKind = SK;
 
     async fn reserve_slot(&self, ctx: &dyn SlotReservationContext) -> SlotSupplierPermit {
-        let g = ctx
+        let (g, _, _) = self.metrics.get_or_init(|| {
+            let meter = ctx.get_metrics_meter().unwrap();
+            let g1 = meter.gauge(MetricParameters::from("custom_reserve"));
+            let g2 = meter.gauge(MetricParameters::from("custom_mark_used"));
+            let g3 = meter.gauge(MetricParameters::from("custom_release"));
+            (g1, g2, g3)
+        });
+        let attrs = ctx
             .get_metrics_meter()
             .unwrap()
-            .gauge(MetricParameters::from("custom_reserve"));
-        g.record(
-            1,
-            &MetricAttributes::OTel {
-                kvs: Arc::new(vec![]),
-            },
-        );
+            .new_attributes(NewAttributes::new(vec![]));
+        g.record(1, &attrs);
         self.inner.reserve_slot(ctx).await
     }
 
@@ -1139,30 +1140,18 @@ where
     }
 
     fn mark_slot_used(&self, ctx: &dyn SlotMarkUsedContext<SlotKind = Self::SlotKind>) {
-        let g = ctx
-            .get_metrics_meter()
-            .unwrap()
-            .gauge(MetricParameters::from("custom_mark_used"));
-        g.record(
-            1,
-            &MetricAttributes::OTel {
-                kvs: Arc::new(vec![]),
-            },
-        );
+        let meter = ctx.get_metrics_meter().unwrap();
+        let attrs = meter.new_attributes(NewAttributes::new(vec![]));
+        let (_, g, _) = self.metrics.get().unwrap();
+        g.record(1, &attrs);
         self.inner.mark_slot_used(ctx);
     }
 
     fn release_slot(&self, ctx: &dyn SlotReleaseContext<SlotKind = Self::SlotKind>) {
-        let g = ctx
-            .get_metrics_meter()
-            .unwrap()
-            .gauge(MetricParameters::from("custom_release"));
-        g.record(
-            1,
-            &MetricAttributes::OTel {
-                kvs: Arc::new(vec![]),
-            },
-        );
+        let meter = ctx.get_metrics_meter().unwrap();
+        let attrs = meter.new_attributes(NewAttributes::new(vec![]));
+        let (_, _, g) = self.metrics.get().unwrap();
+        g.record(1, &attrs);
         self.inner.release_slot(ctx);
     }
 
@@ -1182,6 +1171,7 @@ async fn metrics_available_from_custom_slot_supplier() {
     let mut tb = TunerBuilder::default();
     tb.workflow_slot_supplier(Arc::new(MetricRecordingSlotSupplier::<WorkflowSlotKind> {
         inner: FixedSizeSlotSupplier::new(5),
+        metrics: OnceLock::new(),
     }));
     starter.worker_config.tuner(Arc::new(tb.build()));
     let mut worker = starter.worker().await;
@@ -1202,9 +1192,124 @@ async fn metrics_available_from_custom_slot_supplier() {
         .unwrap();
     worker.run_until_done().await.unwrap();
 
-    tokio::time::sleep(Duration::from_millis(100)).await;
     let body = get_text(format!("http://{addr}/metrics")).await;
     assert!(body.contains("custom_reserve"));
     assert!(body.contains("custom_mark_used"));
     assert!(body.contains("custom_release"));
 }
+
+#[tokio::test]
+async fn test_prometheus_endpoint_integration() {
+    let (telemopts, addr, _aborter) = prom_metrics(None);
+    let meter = telemopts.metrics.unwrap();
+
+    let counter = meter.counter(MetricParameters {
+        name: "test_requests_total".into(),
+        description: "Total number of test requests".into(),
+        unit: "".into(),
+    });
+    let histogram = meter.histogram(MetricParameters {
+        name: "test_request_duration_ms".into(),
+        description: "Duration of test requests in milliseconds".into(),
+        unit: "ms".into(),
+    });
+    let gauge = meter.gauge(MetricParameters {
+        name: "test_active_connections".into(),
+        description: "Number of active test connections".into(),
+        unit: "".into(),
+    });
+
+    counter.adds(5);
+    histogram.records(100);
+    gauge.records(10);
+
+    let url = format!("http://{addr}/metrics");
+    let response = tokio::time::timeout(Duration::from_secs(10), reqwest::get(&url))
+        .await
+        .expect("Request timed out")
+        .expect("Request failed");
+
+    assert!(response.status().is_success());
+
+    let content_type = response
+        .headers()
+        .get("content-type")
+        .unwrap()
+        .to_str()
+        .unwrap();
+    assert!(content_type.contains("text/plain"));
+
+    let body = response.text().await.expect("Failed to read response body");
+
+    assert!(body.contains("test_requests_total"),);
+    assert!(body.contains("test_request_duration_ms"),);
+    assert!(body.contains("test_active_connections"),);
+    assert!(body.contains("test_requests_total 5"),);
+    assert!(body.contains("test_active_connections 10"),);
+    assert!(body.contains("test_request_duration_ms_count 1"),);
+    assert!(body.contains("test_request_duration_ms_sum 100"),);
+}
+
+#[tokio::test]
+async fn test_prometheus_metric_format_consistency() {
+    let (telemopts, addr, _aborter) = prom_metrics(None);
+    let meter = telemopts.metrics.unwrap();
+
+    let workflow_counter = meter.counter(MetricParameters {
+        name: "temporal_workflow_completed_total".into(),
+        description: "Total number of completed workflows".into(),
+        unit: "".into(),
+    });
+    let activity_histogram = meter.histogram_duration(MetricParameters {
+        name: "temporal_activity_execution_latency".into(),
+        description: "Duration of activity execution".into(),
+        unit: "ms".into(),
+    });
+
+    let attrs = meter.new_attributes(NewAttributes::new(vec![]));
+
+    workflow_counter.add(1, &attrs);
+    activity_histogram.record(Duration::from_millis(150), &attrs);
+
+    let url = format!("http://{addr}/metrics");
+    let response = tokio::time::timeout(Duration::from_secs(10), reqwest::get(&url))
+        .await
+        .expect("Request timed out")
+        .expect("Request failed");
+
+    let body = response.text().await.expect("Failed to read response body");
+
+    assert!(body.contains("# HELP temporal_workflow_completed_total"),);
+    assert!(body.contains("# TYPE temporal_workflow_completed_total counter"),);
+    assert!(body.contains("# HELP temporal_activity_execution_latency"),);
+    assert!(body.contains("# TYPE temporal_activity_execution_latency histogram"),);
+    assert!(body.contains("temporal_workflow_completed_total 1"),);
+    assert!(body.contains("temporal_activity_execution_latency_count 1"),);
+    assert!(body.contains("temporal_activity_execution_latency_bucket"),);
+    assert!(body.contains("le=\""));
+}
+
+#[tokio::test]
+async fn prometheus_label_nonsense() {
+    let mut opts_builder = PrometheusExporterOptionsBuilder::default();
+    opts_builder.socket_addr(ANY_PORT.parse().unwrap());
+    let (telemopts, addr, _aborter) = prom_metrics(Some(opts_builder.build().unwrap()));
+    let meter = telemopts.metrics.clone().unwrap();
+
+    let ctr = meter.counter(
+        MetricParametersBuilder::default()
+            .name("some_counter")
+            .build()
+            .unwrap(),
+    );
+    let a1 = meter.new_attributes(NewAttributes::from([MetricKeyValue::new("thing", "foo")]));
+    let a2 = meter.new_attributes(NewAttributes::from([MetricKeyValue::new("blerp", "baz")]));
+    ctr.add(1, &a1);
+    ctr.add(1, &a2);
+    ctr.add(1, &a2);
+    ctr.add(1, &a1);
+
+    let body = get_text(format!("http://{addr}/metrics")).await;
+    assert!(body.contains("some_counter{thing=\"foo\"} 2"));
+    assert!(body.contains("some_counter{blerp=\"baz\"} 2"));
+}

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

@@ -169,7 +169,7 @@ async fn switching_worker_client_changes_poll() {
 
     // Create a worker only on the first server
     let worker = init_worker(
-        init_integ_telem(),
+        init_integ_telem().unwrap(),
         integ_worker_config("my-task-queue")
             // We want a cache so we don't get extra remove-job activations
             .max_cached_workflows(100_usize)

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

@@ -12,6 +12,7 @@ use temporal_sdk_core_protos::{
 };
 use temporal_sdk_core_test_utils::{
     CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf,
+    start_timer_cmd,
 };
 use tokio::join;
 
@@ -124,30 +125,29 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
             let task = core.poll_workflow_activation().await.unwrap();
 
             // When we see the query, handle it.
-            if go_until_query {
-                if let [
+            if go_until_query
+                && let [
                     WorkflowActivationJob {
                         variant: Some(workflow_activation_job::Variant::QueryWorkflow(query)),
                     },
                 ] = task.jobs.as_slice()
-                {
-                    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                        task.run_id,
-                        QueryResult {
-                            query_id: query.query_id.clone(),
-                            variant: Some(
-                                QuerySuccess {
-                                    response: Some(query_resp.into()),
-                                }
-                                .into(),
-                            ),
-                        }
-                        .into(),
-                    ))
-                    .await
-                    .unwrap();
-                    break "".to_string();
-                }
+            {
+                core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                    task.run_id,
+                    QueryResult {
+                        query_id: query.query_id.clone(),
+                        variant: Some(
+                            QuerySuccess {
+                                response: Some(query_resp.into()),
+                            }
+                            .into(),
+                        ),
+                    }
+                    .into(),
+                ))
+                .await
+                .unwrap();
+                break "".to_string();
             }
 
             if matches!(
@@ -213,8 +213,11 @@ async fn query_after_execution_complete(#[case] do_evict: bool) {
     drain_pollers_and_shutdown(core).await;
 }
 
+#[rstest]
+#[case::withou_nde(false)]
+#[case::with_nde(true)]
 #[tokio::test]
-async fn fail_legacy_query() {
+async fn fail_legacy_query(#[case] with_nde: bool) {
     let query_err = "oh no broken";
     let mut starter = CoreWfStarter::new("fail_legacy_query");
     let core = starter.get_worker().await;
@@ -245,28 +248,41 @@ async fn fail_legacy_query() {
     let query_responder = async {
         // Have to replay first since we've evicted
         let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_execution(&task.run_id).await;
-        let task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-            }] => q
-        );
-        core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-            task.run_id,
-            Failure {
-                message: query_err.to_string(),
-                ..Default::default()
-            },
-            None,
-        ))
-        .await
-        .unwrap();
+        if with_nde {
+            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+                task.run_id,
+                start_timer_cmd(1, Duration::from_millis(1)),
+            ))
+            .await
+            .unwrap();
+        } else {
+            core.complete_execution(&task.run_id).await;
+            let task = core.poll_workflow_activation().await.unwrap();
+            assert_matches!(
+                task.jobs.as_slice(),
+                [WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
+                }] => q
+            );
+            core.complete_workflow_activation(WorkflowActivationCompletion::fail(
+                task.run_id,
+                Failure {
+                    message: query_err.to_string(),
+                    ..Default::default()
+                },
+                None,
+            ))
+            .await
+            .unwrap();
+        }
     };
     let (q_resp, _) = join!(query_fut, query_responder);
     // Ensure query response is a failure and has the right message
-    assert_eq!(q_resp.message(), query_err);
+    if with_nde {
+        assert!(q_resp.message().contains("TMPRL1100"));
+    } else {
+        assert_eq!(q_resp.message(), query_err);
+    }
 }
 
 #[tokio::test]

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

@@ -110,6 +110,7 @@ async fn reapplied_updates_due_to_reset() {
     let mut client_mut = client.clone();
     let reset_response = WorkflowService::reset_workflow_execution(
         Arc::make_mut(&mut client_mut),
+        #[allow(deprecated)]
         ResetWorkflowExecutionRequest {
             namespace: client.namespace().into(),
             workflow_execution: Some(WorkflowExecution {
@@ -154,12 +155,6 @@ async fn reapplied_updates_due_to_reset() {
     let with_id = HistoryForReplay::new(history, workflow_id.to_string());
 
     let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
-    // Init workflow comes by itself
-    let act = replay_worker.poll_workflow_activation().await.unwrap();
-    replay_worker
-        .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
-        .await
-        .unwrap();
     // We now recapitulate the actions that the worker took on first execution above, pretending
     // that we always followed the post-reset history.
     // First, we handled the post-reset reapplied update and did not complete the workflow.
@@ -167,7 +162,7 @@ async fn reapplied_updates_due_to_reset() {
         FailUpdate::No,
         CompleteWorkflow::No,
         replay_worker.as_ref(),
-        1,
+        2,
     )
     .await;
     // Then the timer fires

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

@@ -15,13 +15,13 @@ use temporal_sdk_core_api::{
     errors::WorkerValidationError,
     worker::{PollerBehavior, WorkerConfigBuilder, WorkerVersioningStrategy},
 };
+use temporal_sdk_core_protos::temporal::api::enums::v1::WorkflowTaskFailedCause::GrpcMessageTooLarge;
 use temporal_sdk_core_protos::{
     coresdk::workflow_completion::{
         Failure, WorkflowActivationCompletion, workflow_activation_completion::Status,
     },
     temporal::api::{
-        enums::v1::{EventType, WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure},
-        failure::v1::Failure as InnerFailure,
+        enums::v1::EventType, failure::v1::Failure as InnerFailure,
         history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
     },
 };
@@ -188,8 +188,7 @@ async fn oversize_grpc_message() {
     assert!(starter.get_history().await.events.iter().any(|e| {
         e.event_type == EventType::WorkflowTaskFailed as i32
             && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                // TODO tim: Change to custom cause
-                attr.cause == WorkflowWorkerUnhandledFailure as i32
+                attr.cause == GrpcMessageTooLarge as i32
                     && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
             } else {
                 false

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

@@ -131,13 +131,9 @@ async fn sets_deployment_info_on_task_responses(#[values(true, false)] use_defau
         );
     }
     assert_eq!(wft_complete.worker_deployment_name, deploy_name);
-    #[allow(deprecated)] // odd looking hack since can't put attr macro on macro
-    {
-        assert_eq!(
-            wft_complete.worker_deployment_version,
-            format!("{deploy_name}.1.0")
-        );
-    }
+    let dv = wft_complete.deployment_version.unwrap();
+    assert_eq!(dv.deployment_name, deploy_name);
+    assert_eq!(dv.build_id, "1.0");
 }
 
 #[tokio::test]

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

@@ -270,12 +270,10 @@ impl WorkerInterceptor for LACancellerInterceptor {
         if let Some(workflow_activation_completion::Status::Successful(
             workflow_completion::Success { commands, .. },
         )) = completion.status.as_ref()
-        {
-            if let Some(&Variant::CompleteWorkflowExecution(_)) =
+            && let Some(&Variant::CompleteWorkflowExecution(_)) =
                 commands.last().and_then(|v| v.variant.as_ref())
-            {
-                self.token.cancel();
-            }
+        {
+            self.token.cancel();
         }
     }
     fn on_shutdown(&self, _: &temporal_sdk::Worker) {