@temporalio/core-bridge 1.11.0 → 1.11.2

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

@@ -42,8 +42,8 @@ use temporal_sdk_core_protos::{
         activity_result::{self as ar, activity_resolution, ActivityResolution},
         common::VersioningIntent,
         workflow_activation::{
-            remove_from_cache::EvictionReason, workflow_activation_job, FireTimer, ResolveActivity,
-            StartWorkflow, UpdateRandomSeed, WorkflowActivationJob,
+            remove_from_cache::EvictionReason, workflow_activation_job, FireTimer,
+            InitializeWorkflow, ResolveActivity, UpdateRandomSeed, WorkflowActivationJob,
         },
         workflow_commands::{
             update_response::Response, workflow_command, ActivityCancellationType, CancelTimer,
@@ -112,7 +112,7 @@ async fn single_timer(#[case] worker: Worker, #[case] evict: WorkflowCachingPoli
         evict,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![start_timer_cmd(1, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
@@ -125,10 +125,10 @@ async fn single_timer(#[case] worker: Worker, #[case] evict: WorkflowCachingPoli
 }
 
 #[rstest(worker,
-case::incremental(single_activity_setup(&[1, 2])),
-case::incremental_activity_failure(single_activity_failure_setup(&[1, 2])),
-case::replay(single_activity_setup(&[2])),
-case::replay_activity_failure(single_activity_failure_setup(&[2]))
+    case::incremental(single_activity_setup(&[1, 2])),
+    case::incremental_activity_failure(single_activity_failure_setup(&[1, 2])),
+    case::replay(single_activity_setup(&[2])),
+    case::replay_activity_failure(single_activity_failure_setup(&[2]))
 )]
 #[tokio::test]
 async fn single_activity_completion(worker: Worker) {
@@ -137,7 +137,7 @@ async fn single_activity_completion(worker: Worker) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     activity_id: "fake_activity".to_string(),
                     ..default_act_sched()
@@ -171,7 +171,7 @@ async fn parallel_timer_test_across_wf_bridge(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![
                     start_timer_cmd(timer_1_id, Duration::from_secs(1)),
                     start_timer_cmd(timer_2_id, Duration::from_secs(1)),
@@ -223,7 +223,7 @@ async fn timer_cancel(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![
                     start_timer_cmd(cancel_timer_id, Duration::from_secs(1)),
                     start_timer_cmd(timer_id, Duration::from_secs(1)),
@@ -260,7 +260,7 @@ async fn scheduled_activity_cancellation_try_cancel(hist_batches: &'static [usiz
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -297,7 +297,7 @@ async fn scheduled_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -319,7 +319,7 @@ async fn scheduled_activity_timeout(hist_batches: &'static [usize]) {
                                         status: Some(activity_resolution::Status::Failed(ar::Failure {
                                             failure: Some(failure)
                                         })),
-                                    })
+                                    }), ..
                                 }
                             )),
                         }
@@ -350,7 +350,7 @@ async fn started_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_seq.to_string(),
@@ -361,7 +361,7 @@ async fn started_activity_timeout(hist_batches: &'static [usize]) {
             // Activity is getting resolved right away as it has been timed out.
             gen_assert_and_reply(
                 &|res| {
-                assert_matches!(
+                    assert_matches!(
                     res.jobs.as_slice(),
                     [
                         WorkflowActivationJob {
@@ -372,7 +372,7 @@ async fn started_activity_timeout(hist_batches: &'static [usize]) {
                                         status: Some(activity_resolution::Status::Failed(ar::Failure {
                                             failure: Some(failure)
                                         })),
-                                    })
+                                    }), ..
                                 }
                             )),
                         }
@@ -405,7 +405,7 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_id.to_string(),
@@ -421,10 +421,10 @@ async fn cancelled_activity_timeout(hist_batches: &'static [usize]) {
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        seq: _,
                         result: Some(ActivityResolution {
                             status: Some(activity_resolution::Status::Cancelled(..)),
-                        })
+                        }),
+                        ..
                     }
                 )),
                 vec![CompleteWorkflowExecution { result: None }.into()],
@@ -557,7 +557,7 @@ async fn verify_activity_cancellation(
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_seq,
                     activity_id: activity_seq.to_string(),
@@ -574,10 +574,10 @@ async fn verify_activity_cancellation(
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        seq: _,
                         result: Some(ActivityResolution {
                             status: Some(activity_resolution::Status::Cancelled(..)),
-                        })
+                        }),
+                        ..
                     }
                 )),
                 vec![CompleteWorkflowExecution { result: None }.into()],
@@ -625,7 +625,7 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, wo
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: activity_id.to_string(),
@@ -647,10 +647,10 @@ async fn verify_activity_cancellation_wait_for_cancellation(activity_id: u32, wo
             gen_assert_and_reply(
                 &job_assert!(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {
-                        seq: _,
                         result: Some(ActivityResolution {
                             status: Some(activity_resolution::Status::Cancelled(..)),
-                        })
+                        }),
+                        ..
                     }
                 )),
                 vec![CompleteWorkflowExecution { result: None }.into()],
@@ -682,8 +682,8 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                     assert_matches!(
                         res.jobs.as_slice(),
                         [WorkflowActivationJob {
-                            variant: Some(workflow_activation_job::Variant::StartWorkflow(
-                            StartWorkflow{randomness_seed, ..}
+                            variant: Some(workflow_activation_job::Variant::InitializeWorkflow(
+                            InitializeWorkflow{randomness_seed, ..}
                             )),
                         }] => {
                         randomness_seed_from_start.store(*randomness_seed, Ordering::SeqCst);
@@ -692,17 +692,19 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                 },
                 vec![start_timer_cmd(timer_1_id, Duration::from_secs(1))],
             ),
+            // The random seed update should always be the first job
             gen_assert_and_reply(
                 &|res| {
                     assert_matches!(
                         res.jobs.as_slice(),
                         [WorkflowActivationJob {
-                            variant: Some(workflow_activation_job::Variant::FireTimer(_),),
-                        },
-                        WorkflowActivationJob {
                             variant: Some(workflow_activation_job::Variant::UpdateRandomSeed(
                                 UpdateRandomSeed{randomness_seed})),
-                        }] => {
+                        },
+                            WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::FireTimer(_),),
+                        },
+                        ] => {
                             assert_ne!(randomness_seed_from_start.load(Ordering::SeqCst),
                                       *randomness_seed);
                         }
@@ -731,7 +733,7 @@ async fn cancel_timer_before_sent_wf_bridge() {
         &core,
         NonSticky,
         &[gen_assert_and_reply(
-            &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+            &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
             vec![
                 start_timer_cmd(cancel_timer_id, Duration::from_secs(1)),
                 CancelTimer {
@@ -802,7 +804,7 @@ async fn simple_timer_fail_wf_execution(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![start_timer_cmd(timer_id, Duration::from_secs(1))],
             ),
             gen_assert_and_reply(
@@ -833,7 +835,7 @@ async fn two_signals(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 // Task is completed with no commands
                 vec![],
             ),
@@ -957,7 +959,7 @@ async fn activity_not_canceled_on_replay_repro(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 // Start timer and activity
                 vec![
                     ScheduleActivity {
@@ -1003,7 +1005,7 @@ async fn activity_not_canceled_when_also_completed_repro(hist_batches: &'static
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: "act-1".to_string(),
@@ -1061,7 +1063,7 @@ async fn lots_of_workflows() {
             while let Ok(wft) = worker.poll_workflow_activation().await {
                 let job = &wft.jobs[0];
                 let reply = match job.variant {
-                    Some(workflow_activation_job::Variant::StartWorkflow(_)) => {
+                    Some(workflow_activation_job::Variant::InitializeWorkflow(_)) => {
                         start_timer_cmd(1, Duration::from_secs(1))
                     }
                     Some(workflow_activation_job::Variant::RemoveFromCache(_)) => {
@@ -1104,7 +1106,7 @@ async fn wft_timeout_repro(hist_batches: &'static [usize]) {
         NonSticky,
         &[
             gen_assert_and_reply(
-                &job_assert!(workflow_activation_job::Variant::StartWorkflow(_)),
+                &job_assert!(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 vec![ScheduleActivity {
                     seq: activity_id,
                     activity_id: activity_id.to_string(),
@@ -1226,7 +1228,7 @@ async fn new_server_work_while_eviction_outstanding_doesnt_overwrite_activation(
     let start_again = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         start_again.jobs[0].variant,
-        Some(workflow_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::InitializeWorkflow(_))
     );
 }
 
@@ -1441,7 +1443,7 @@ async fn lang_slower_than_wft_timeouts() {
     let start_again = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         start_again.jobs[0].variant,
-        Some(workflow_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::InitializeWorkflow(_))
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         start_again.run_id,
@@ -1602,7 +1604,7 @@ async fn cache_miss_will_fetch_history() {
     assert_matches!(
         activation.jobs.as_slice(),
         [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+            variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
         }]
     );
     // Force an eviction (before complete matters, so that we will be sure the eviction is queued
@@ -1631,7 +1633,7 @@ async fn cache_miss_will_fetch_history() {
             assert_matches!(
                 activation.jobs.as_slice(),
                 [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+                    variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
                 }]
             );
         }
@@ -1829,7 +1831,7 @@ async fn poll_faster_than_complete_wont_overflow_cache() {
     for (i, p_res) in [&p1, &p2, &p3].into_iter().enumerate() {
         assert_matches!(
             &p_res.jobs[0].variant,
-            Some(workflow_activation_job::Variant::StartWorkflow(sw))
+            Some(workflow_activation_job::Variant::InitializeWorkflow(sw))
             if sw.workflow_id == format!("wf-{}", i + 1)
         );
     }
@@ -1874,7 +1876,7 @@ async fn poll_faster_than_complete_wont_overflow_cache() {
         let res = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             &res.jobs[0].variant,
-            Some(workflow_activation_job::Variant::StartWorkflow(sw))
+            Some(workflow_activation_job::Variant::InitializeWorkflow(sw))
             if sw.workflow_id == format!("wf-{}", 4)
         );
         res
@@ -1919,7 +1921,7 @@ async fn poll_faster_than_complete_wont_overflow_cache() {
         let res = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             &res.jobs[0].variant,
-            Some(workflow_activation_job::Variant::StartWorkflow(sw))
+            Some(workflow_activation_job::Variant::InitializeWorkflow(sw))
             if sw.workflow_id == "wf-5"
         );
     };
@@ -2004,7 +2006,7 @@ async fn autocompletes_wft_no_work() {
     assert_matches!(
         act.jobs.as_slice(),
         [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+            variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
         }]
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
@@ -2187,7 +2189,7 @@ async fn ignorable_events_are_ok(#[values(true, false)] attribs_unset: bool) {
     let act = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         act.jobs[0].variant,
-        Some(workflow_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::InitializeWorkflow(_))
     );
 }
 
@@ -2235,7 +2237,7 @@ async fn fetching_to_continue_replay_works() {
     let act = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         act.jobs[0].variant,
-        Some(workflow_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::InitializeWorkflow(_))
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
         .await
@@ -2286,7 +2288,7 @@ async fn fetching_error_evicts_wf() {
     let act = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         act.jobs[0].variant,
-        Some(workflow_activation_job::Variant::StartWorkflow(_))
+        Some(workflow_activation_job::Variant::InitializeWorkflow(_))
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
         .await
@@ -2441,10 +2443,10 @@ async fn lang_internal_flag_with_update() {
         act.jobs.as_slice(),
         [
             WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::DoUpdate(_)),
+                variant: Some(workflow_activation_job::Variant::InitializeWorkflow(_)),
             },
             WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+                variant: Some(workflow_activation_job::Variant::DoUpdate(_)),
             },
         ]
     );
@@ -2639,14 +2641,13 @@ async fn jobs_are_in_appropriate_order() {
     let core = mock_worker(mock);
 
     let act = core.poll_workflow_activation().await.unwrap();
-    // Patch notifications always come first
     assert_matches!(
         act.jobs[0].variant.as_ref().unwrap(),
-        workflow_activation_job::Variant::NotifyHasPatch(_)
+        workflow_activation_job::Variant::InitializeWorkflow(_)
     );
     assert_matches!(
         act.jobs[1].variant.as_ref().unwrap(),
-        workflow_activation_job::Variant::StartWorkflow(_)
+        workflow_activation_job::Variant::NotifyHasPatch(_)
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         act.run_id,

package/sdk-core/core/src/ephemeral_server/mod.rs

@@ -46,7 +46,7 @@ pub struct TemporalDevServerConfig {
     /// Log format and level
     #[builder(default = "(\"pretty\".to_owned(), \"warn\".to_owned())")]
     pub log: (String, String),
-    /// Additional arguments to Temporalite.
+    /// Additional arguments to Temporal dev server.
     #[builder(default)]
     pub extra_args: Vec<String>,
 }
@@ -567,8 +567,10 @@ async fn download_and_extract(
 #[cfg(test)]
 mod tests {
     use super::get_free_port;
-    use std::collections::HashSet;
-    use std::net::{TcpListener, TcpStream};
+    use std::{
+        collections::HashSet,
+        net::{TcpListener, TcpStream},
+    };
 
     #[test]
     fn get_free_port_no_double() {

package/sdk-core/core/src/protosext/mod.rs

@@ -109,6 +109,9 @@ impl TryFrom<PollWorkflowTaskQueueResponse> for ValidPollWFTQResponse {
                 messages,
                 ..
             } => {
+                if task_token.is_empty() {
+                    return Err(anyhow!("missing task token"));
+                }
                 let query_requests = queries
                     .into_iter()
                     .map(|(id, q)| query_to_job(id, q))

package/sdk-core/core/src/telemetry/mod.rs

@@ -160,15 +160,7 @@ impl CoreTelemetry for TelemetryInstance {
 ///
 /// See [TelemetryOptions] docs for more on configuration.
 pub fn telemetry_init(opts: TelemetryOptions) -> Result<TelemetryInstance, anyhow::Error> {
-    // This is a bit odd, but functional. It's desirable to create a separate tokio runtime for
-    // metrics handling, since tests typically use a single-threaded runtime and initializing
-    // pipeline requires us to know if the runtime is single or multithreaded, we will crash
-    // in one case or the other. There does not seem to be a way to tell from the current runtime
-    // handle if it is single or multithreaded. Additionally, we can isolate metrics work this
-    // way which is nice.
-    // Parts of telem dat ====
     let mut logs_out = None;
-    // =======================
 
     // Tracing subscriber layers =========
     let mut console_pretty_layer = None;

package/sdk-core/core/src/telemetry/otel.rs

@@ -35,7 +35,7 @@ use temporal_sdk_core_api::telemetry::{
     MetricTemporality, OtelCollectorOptions, PrometheusExporterOptions,
 };
 use tokio::task::AbortHandle;
-use tonic::metadata::MetadataMap;
+use tonic::{metadata::MetadataMap, transport::ClientTlsConfig};
 
 /// Chooses appropriate aggregators for our metrics
 #[derive(Debug, Clone)]
@@ -160,8 +160,12 @@ impl<U> MemoryGauge<U> {
 pub fn build_otlp_metric_exporter(
     opts: OtelCollectorOptions,
 ) -> Result<CoreOtelMeter, anyhow::Error> {
-    let exporter = opentelemetry_otlp::TonicExporterBuilder::default()
-        .with_endpoint(opts.url.to_string())
+    let mut exporter =
+        opentelemetry_otlp::TonicExporterBuilder::default().with_endpoint(opts.url.to_string());
+    if opts.url.scheme() == "https" || opts.url.scheme() == "grpcs" {
+        exporter = exporter.with_tls_config(ClientTlsConfig::new().with_native_roots());
+    }
+    let exporter = exporter
         .with_metadata(MetadataMap::from_headers((&opts.headers).try_into()?))
         .build_metrics_exporter(
             Box::new(SDKAggSelector::new(opts.use_seconds_for_durations)),

package/sdk-core/core/src/worker/activities/activity_task_poller_stream.rs

@@ -35,6 +35,10 @@ pub(crate) fn new_activity_task_poller(
                                 state.metrics.act_poll_timeout();
                                 continue;
                             }
+                            if let Some(reason) = validate_activity_task(&resp) {
+                                warn!("Received invalid activity task ({}): {:?}", reason, &resp);
+                                continue;
+                            }
                             Some(Ok(PermittedTqResp { permit, resp }))
                         }
                         Some(Err(e)) => {
@@ -65,3 +69,10 @@ pub(crate) fn new_activity_task_poller(
         }
     })
 }
+
+fn validate_activity_task(task: &PollActivityTaskQueueResponse) -> Option<&'static str> {
+    if task.task_token.is_empty() {
+        return Some("missing task token");
+    }
+    None
+}

package/sdk-core/core/src/worker/activities.rs

@@ -506,7 +506,7 @@ where
                                 )))
                             }
                         } else {
-                            debug!(task_token = ?next_pc.task_token,
+                            debug!(task_token = %next_pc.task_token,
                                    "Unknown activity task when issuing cancel");
                             // If we can't find the activity here, it's already been completed,
                             // in which case issuing a cancel again is pointless.

package/sdk-core/core/src/worker/mod.rs

@@ -587,16 +587,16 @@ impl Worker {
     /// Attempt to record an activity heartbeat
     pub(crate) fn record_heartbeat(&self, details: ActivityHeartbeat) {
         if let Some(at_mgr) = self.at_task_mgr.as_ref() {
-            let tt = details.task_token.clone();
+            let tt = TaskToken(details.task_token.clone());
             if let Err(e) = at_mgr.record_heartbeat(details) {
-                warn!(task_token = ?tt, details = ?e, "Activity heartbeat failed.");
+                warn!(task_token = %tt, details = ?e, "Activity heartbeat failed.");
             }
         }
     }
 
     #[instrument(skip(self, task_token, status),
-                 fields(task_token=%&task_token, status=%&status,
-                        task_queue=%self.config.task_queue, workflow_id, run_id))]
+        fields(task_token=%&task_token, status=%&status,
+               task_queue=%self.config.task_queue, workflow_id, run_id))]
     pub(crate) async fn complete_activity(
         &self,
         task_token: TaskToken,
@@ -637,8 +637,8 @@ impl Worker {
     }
 
     #[instrument(skip(self, completion),
-                 fields(completion=%&completion, run_id=%completion.run_id, workflow_id,
-                        task_queue=%self.config.task_queue))]
+        fields(completion=%&completion, run_id=%completion.run_id, workflow_id,
+               task_queue=%self.config.task_queue))]
     pub(crate) async fn complete_workflow_activation(
         &self,
         completion: WorkflowActivationCompletion,

package/sdk-core/core/src/worker/slot_provider.rs

@@ -53,8 +53,8 @@ impl SlotTrait for Slot {
     }
 }
 
-#[derive(derive_more::DebugCustom)]
-#[debug(fmt = "SlotProvider {{ namespace:{namespace}, task_queue: {task_queue} }}")]
+#[derive(derive_more::Debug)]
+#[debug("SlotProvider {{ namespace:{namespace}, task_queue: {task_queue} }}")]
 pub(super) struct SlotProvider {
     namespace: String,
     task_queue: String,
@@ -108,6 +108,7 @@ mod tests {
     // make validate_wft() happy
     fn new_validatable_response() -> PollWorkflowTaskQueueResponse {
         PollWorkflowTaskQueueResponse {
+            task_token: vec![1, 3, 3, 7],
             workflow_execution_task_queue: Some(TaskQueue::default()),
             workflow_execution: Some(WorkflowExecution::default()),
             workflow_type: Some(WorkflowType::default()),
@@ -130,7 +131,7 @@ mod tests {
 
         let slot = provider
             .try_reserve_wft_slot()
-            .expect("failed to reserver slot");
+            .expect("failed to reserve slot");
         let p = slot.schedule_wft(new_validatable_response());
         assert!(p.is_ok());
         assert!(external_wft_rx.recv().await.is_some());

package/sdk-core/core/src/worker/tuner/resource_based.rs

@@ -440,7 +440,7 @@ impl RealSysInfo {
         lock.refresh_memory();
         lock.refresh_cpu_usage();
         let mem = lock.used_memory();
-        let cpu = lock.global_cpu_info().cpu_usage() as f64 / 100.;
+        let cpu = lock.global_cpu_usage() as f64 / 100.;
         self.cur_mem_usage.store(mem, Ordering::Release);
         self.cur_cpu_usage.store(cpu.to_bits(), Ordering::Release);
         self.last_refresh.store(Instant::now());

package/sdk-core/core/src/worker/workflow/driven_workflow.rs

@@ -3,10 +3,13 @@ use crate::{
     worker::workflow::{OutgoingJob, WFCommand, WorkflowStartedInfo},
 };
 use prost_types::Timestamp;
-use std::sync::mpsc::{self, Receiver, Sender};
+use std::{
+    collections::HashMap,
+    sync::mpsc::{self, Receiver, Sender},
+};
 use temporal_sdk_core_protos::{
     coresdk::workflow_activation::{start_workflow_from_attribs, WorkflowActivationJob},
-    temporal::api::history::v1::WorkflowExecutionStartedEventAttributes,
+    temporal::api::{common::v1::Payload, history::v1::WorkflowExecutionStartedEventAttributes},
     utilities::TryIntoOrNone,
 };
 
@@ -14,6 +17,7 @@ use temporal_sdk_core_protos::{
 /// command responses pulled out.
 pub(crate) struct DrivenWorkflow {
     started_attrs: Option<WorkflowStartedInfo>,
+    search_attribute_modifications: HashMap<String, Payload>,
     incoming_commands: Receiver<Vec<WFCommand>>,
     /// Outgoing activation jobs that need to be sent to the lang sdk
     outgoing_wf_activation_jobs: Vec<OutgoingJob>,
@@ -25,6 +29,7 @@ impl DrivenWorkflow {
         (
             Self {
                 started_attrs: None,
+                search_attribute_modifications: Default::default(),
                 incoming_commands: rx,
                 outgoing_wf_activation_jobs: vec![],
             },
@@ -85,4 +90,25 @@ impl DrivenWorkflow {
         debug!(in_cmds = %in_cmds.display(), "wf bridge iteration fetch");
         in_cmds
     }
+
+    /// Lang sent us an SA upsert command - use it to update our current view of search attributes.
+    pub(crate) fn search_attributes_update(&mut self, update: HashMap<String, Payload>) {
+        self.search_attribute_modifications.extend(update);
+    }
+
+    /// Return a view of the "current" state of search attributes. IE: The initial attributes
+    /// plus any changes during the lifetime of the workflow.
+    pub(crate) fn get_current_search_attributes(&self) -> HashMap<String, Payload> {
+        let mut retme = self
+            .started_attrs
+            .as_ref()
+            .and_then(|si| si.search_attrs.as_ref().map(|sa| sa.indexed_fields.clone()))
+            .unwrap_or_default();
+        retme.extend(
+            self.search_attribute_modifications
+                .iter()
+                .map(|(a, b)| (a.clone(), b.clone())),
+        );
+        retme
+    }
 }

package/sdk-core/core/src/worker/workflow/history_update.rs

@@ -78,8 +78,8 @@ pub(crate) enum NextWFT {
     NeedFetch,
 }
 
-#[derive(derive_more::DebugCustom)]
-#[debug(fmt = "HistoryPaginator(run_id: {run_id})")]
+#[derive(derive_more::Debug)]
+#[debug("HistoryPaginator(run_id: {run_id})")]
 pub(crate) struct HistoryPaginator {
     pub(crate) wf_id: String,
     pub(crate) run_id: String,