@temporalio/core-bridge 1.11.0 → 1.11.2

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -340,7 +340,7 @@ impl StateMachineDefinition {
         let state_variants = states.iter().map(|s| {
             let statestr = s.to_string();
             quote! {
-                #[display(fmt=#statestr)]
+                #[display(#statestr)]
                 #s(#s)
             }
         });
@@ -397,7 +397,7 @@ impl StateMachineDefinition {
             .map(|v| {
                 let vname = v.ident.to_string();
                 quote! {
-                    #[display(fmt=#vname)]
+                    #[display(#vname)]
                     #v
                 }
             })

package/sdk-core/sdk/src/lib.rs

@@ -97,6 +97,7 @@ use temporal_sdk_core_protos::{
     },
     temporal::api::{
         common::v1::Payload,
+        enums::v1::WorkflowTaskFailedCause,
         failure::v1::{failure, Failure},
     },
     TaskToken,
@@ -252,7 +253,7 @@ impl Worker {
                         let wf_half = &*wf_half;
                         async move {
                             join_handle.await??;
-                            info!(run_id=%run_id, "Removing workflow from cache");
+                            debug!(run_id=%run_id, "Removing workflow from cache");
                             wf_half.workflows.borrow_mut().remove(&run_id);
                             Ok(())
                         }
@@ -395,16 +396,24 @@ impl WorkflowHalf {
         let mut res = None;
         let run_id = activation.run_id.clone();
 
-        // If the activation is to start a workflow, create a new workflow driver for it,
+        // If the activation is to init a workflow, create a new workflow driver for it,
         // using the function associated with that workflow id
         if let Some(sw) = activation.jobs.iter().find_map(|j| match j.variant {
-            Some(Variant::StartWorkflow(ref sw)) => Some(sw),
+            Some(Variant::InitializeWorkflow(ref sw)) => Some(sw),
             _ => None,
         }) {
             let workflow_type = &sw.workflow_type;
             let wf_fns_borrow = self.workflow_fns.borrow();
             let Some(wf_function) = wf_fns_borrow.get(workflow_type) else {
                 warn!("Workflow type {workflow_type} not found");
+
+                completions_tx
+                    .send(WorkflowActivationCompletion::fail(
+                        run_id,
+                        format!("Workflow type {workflow_type} not found").into(),
+                        Some(WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure),
+                    ))
+                    .expect("Completion channel intact");
                 return Ok(None);
             };
 
@@ -445,6 +454,24 @@ impl WorkflowHalf {
                 .send(activation)
                 .expect("Workflow should exist if we're sending it an activation");
         } else {
+            // When we failed to start a workflow, we never inserted it into the cache.
+            // But core sends us a `RemoveFromCache` job when we mark the StartWorkflow workflow activation
+            // as a failure, which we need to complete.
+            // Other SDKs add the workflow to the cache even when the workflow type is unknown/not found.
+            // To circumvent this, we simply mark any RemoveFromCache job for workflows that are not in the cache as complete.
+            if activation.jobs.len() == 1
+                && matches!(
+                    activation.jobs.first().map(|j| &j.variant),
+                    Some(Some(Variant::RemoveFromCache(_)))
+                )
+            {
+                completions_tx
+                    .send(WorkflowActivationCompletion::from_cmds(run_id, vec![]))
+                    .expect("Completion channel intact");
+                return Ok(None);
+            }
+
+            // In all other cases, we want to panic as the runtime could be in an inconsistent state at this point.
             bail!(
                 "Got activation {:?} for unknown workflow {}",
                 activation,

package/sdk-core/sdk/src/workflow_context.rs

@@ -13,11 +13,12 @@ use crate::{
 };
 use crossbeam_channel::{Receiver, Sender};
 use futures::{task::Context, FutureExt, Stream, StreamExt};
-use parking_lot::RwLock;
+use parking_lot::{RwLock, RwLockReadGuard};
 use std::{
     collections::HashMap,
     future::Future,
     marker::PhantomData,
+    ops::Deref,
     pin::Pin,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -40,7 +41,7 @@ use temporal_sdk_core_protos::{
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
         },
     },
-    temporal::api::common::v1::{Memo, Payload},
+    temporal::api::common::v1::{Memo, Payload, SearchAttributes},
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -123,6 +124,16 @@ impl WfContext {
         self.shared.read().current_build_id.clone()
     }
 
+    /// Return current values for workflow search attributes
+    pub fn search_attributes(&self) -> impl Deref<Target = SearchAttributes> + '_ {
+        RwLockReadGuard::map(self.shared.read(), |s| &s.search_attributes)
+    }
+
+    /// Return the workflow's randomness seed
+    pub fn random_seed(&self) -> u64 {
+        self.shared.read().random_seed
+    }
+
     /// A future that resolves if/when the workflow is cancelled
     pub async fn cancelled(&self) {
         if *self.am_cancelled.borrow() {
@@ -412,6 +423,8 @@ pub(crate) struct WfContextSharedData {
     pub(crate) wf_time: Option<SystemTime>,
     pub(crate) history_length: u32,
     pub(crate) current_build_id: Option<String>,
+    pub(crate) search_attributes: SearchAttributes,
+    pub(crate) random_seed: u64,
 }
 
 /// Helper Wrapper that can drain the channel into a Vec<SignalData> in a blocking way.  Useful

package/sdk-core/sdk/src/workflow_future.rs

@@ -145,7 +145,11 @@ impl WorkflowFuture {
     fn fail_wft(&self, run_id: String, fail: Error) {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
-            .send(WorkflowActivationCompletion::fail(run_id, fail.into()))
+            .send(WorkflowActivationCompletion::fail(
+                run_id,
+                fail.into(),
+                None,
+            ))
             .expect("Completion channel intact");
     }
 
@@ -171,13 +175,14 @@ impl WorkflowFuture {
     ) -> Result<bool, Error> {
         if let Some(v) = variant {
             match v {
-                Variant::StartWorkflow(_) => {
-                    // TODO: Can assign randomness seed whenever needed
+                Variant::InitializeWorkflow(_) => {
+                    // Don't do anything in here. Init workflow is looked at earlier, before
+                    // jobs are handled, and may have information taken out of it to avoid clones.
                 }
                 Variant::FireTimer(FireTimer { seq }) => {
                     self.unblock(UnblockEvent::Timer(seq, TimerResult::Fired))?
                 }
-                Variant::ResolveActivity(ResolveActivity { seq, result }) => {
+                Variant::ResolveActivity(ResolveActivity { seq, result, .. }) => {
                     self.unblock(UnblockEvent::Activity(
                         seq,
                         Box::new(result.context("Activity must have result")?),
@@ -196,7 +201,9 @@ impl WorkflowFuture {
                     seq,
                     Box::new(result.context("Child Workflow execution must have a result")?),
                 ))?,
-                Variant::UpdateRandomSeed(_) => (),
+                Variant::UpdateRandomSeed(rs) => {
+                    self.wf_ctx.shared.write().random_seed = rs.randomness_seed;
+                }
                 Variant::QueryWorkflow(q) => {
                     error!(
                         "Queries are not implemented in the Rust SDK. Got query '{}'",
@@ -307,7 +314,7 @@ impl Future for WorkflowFuture {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         'activations: loop {
             // WF must always receive an activation first before responding with commands
-            let activation = match self.incoming_activations.poll_recv(cx) {
+            let mut activation = match self.incoming_activations.poll_recv(cx) {
                 Poll::Ready(a) => match a {
                     Some(act) => act,
                     None => {
@@ -335,16 +342,28 @@ impl Future for WorkflowFuture {
 
             let mut die_of_eviction_when_done = false;
             let mut activation_cmds = vec![];
+            // Assign initial state from start workflow job
+            if let Some(start_info) = activation.jobs.iter_mut().find_map(|j| {
+                if let Some(Variant::InitializeWorkflow(s)) = j.variant.as_mut() {
+                    Some(s)
+                } else {
+                    None
+                }
+            }) {
+                let mut wlock = self.wf_ctx.shared.write();
+                wlock.random_seed = start_info.randomness_seed;
+                wlock.search_attributes = start_info.search_attributes.take().unwrap_or_default();
+            };
             // Lame hack to avoid hitting "unregistered" update handlers in a situation where
             // the history has no commands until an update is accepted. Will go away w/ SDK redesign
             if activation
                 .jobs
                 .iter()
-                .any(|j| matches!(j.variant, Some(Variant::StartWorkflow(_))))
+                .any(|j| matches!(j.variant, Some(Variant::InitializeWorkflow(_))))
                 && activation.jobs.iter().all(|j| {
                     matches!(
                         j.variant,
-                        Some(Variant::StartWorkflow(_) | Variant::DoUpdate(_))
+                        Some(Variant::InitializeWorkflow(_) | Variant::DoUpdate(_))
                     )
                 })
             {
@@ -443,6 +462,7 @@ impl WorkflowFuture {
                             message: errmsg,
                             ..Default::default()
                         },
+                        None,
                     ))
                     .expect("Completion channel intact");
                 // Loop back up because we're about to get evicted

package/sdk-core/sdk-core-protos/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -23,22 +23,38 @@ import "temporal/sdk/core/common/common.proto";
 // ## Job ordering guarantees and semantics
 //
 // Core will, by default, order jobs within the activation as follows:
-// `patches -> signals/updates -> other -> queries -> evictions`
+// 1. init workflow
+// 2. patches
+// 3. random-seed-updates
+// 4. signals/updates
+// 5. all others
+// 6. local activity resolutions
+// 7. queries
+// 8. evictions
 //
 // This is because:
 // * Patches are expected to apply to the entire activation
 // * Signal and update handlers should be invoked before workflow routines are iterated. That is to
 //   say before the users' main workflow function and anything spawned by it is allowed to continue.
+// * Local activities resolutions go after other normal jobs because while *not* replaying, they
+//   will always take longer than anything else that produces an immediate job (which is
+//   effectively instant). When *replaying* we need to scan ahead for LA markers so that we can
+//   resolve them in the same activation that they completed in when not replaying. However, doing
+//   so would, by default, put those resolutions *before* any other immediate jobs that happened
+//   in that same activation (prime example: cancelling not-wait-for-cancel activities). So, we do
+//   this to ensure the LA resolution happens after that cancel (or whatever else it may be) as it
+//   normally would have when executing.
 // * Queries always go last (and, in fact, always come in their own activation)
 // * Evictions also always come in their own activation
 //
-// The downside of this reordering is that a signal or update handler may not observe that some
-// other event had already happened (ex: an activity completed) when it is first invoked, though it
-// will subsequently when workflow routines are driven. Core only does this reordering to make life
-// easier for languages that cannot explicitly control when workflow routines are iterated.
-// Languages that can explicitly control such iteration should prefer to apply all the jobs to state
-// (by resolving promises/futures, invoking handlers, etc as they iterate over the jobs) and then
-// only *after* that is done, drive the workflow routines.
+// Core does this reordering to ensure that langs observe jobs in the same order during replay as
+// they would have during execution. However, in principle, this ordering is not necessary
+// (excepting queries/evictions, which definitely must come last) if lang layers apply all jobs to
+// state *first* (by resolving promises/futures, marking handlers to be invoked, etc as they iterate
+// over the jobs) and then only *after* that is done, drive coroutines/threads/whatever. If
+// execution works this way, then determinism is only impacted by the order routines are driven in
+// (which must be stable based on lang implementation or convention), rather than the order jobs are
+// processed.
 //
 // ## Evictions
 //
@@ -74,8 +90,8 @@ message WorkflowActivation {
 
 message WorkflowActivationJob {
     oneof variant {
-        // Begin a workflow for the first time
-        StartWorkflow start_workflow = 1;
+        // A workflow is starting, record all of the information from its start event
+        InitializeWorkflow initialize_workflow = 1;
         // A timer has fired, allowing whatever was waiting on it (if anything) to proceed
         FireTimer fire_timer = 2;
         // Workflow was reset. The randomness seed must be updated.
@@ -110,8 +126,8 @@ message WorkflowActivationJob {
     }
 }
 
-// Start a new workflow
-message StartWorkflow {
+// Initialize a new workflow
+message InitializeWorkflow {
     // The identifier the lang-specific sdk uses to execute workflow code
     string workflow_type = 1;
     // The workflow id used on the temporal server
@@ -175,6 +191,9 @@ message ResolveActivity {
     // Sequence number as provided by lang in the corresponding ScheduleActivity command
     uint32 seq = 1;
     activity_result.ActivityResolution result = 2;
+    // Set to true if the resolution is for a local activity. This is used internally by Core and
+    // lang does not need to care about it.
+    bool is_local = 3;
 }
 
 // Notify a workflow that a start child workflow execution request has succeeded, failed or was

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -436,8 +436,10 @@ pub mod coresdk {
     pub mod workflow_activation {
         use crate::{
             coresdk::{
+                activity_result::{activity_resolution, ActivityResolution},
                 common::NamespacedWorkflowExecution,
-                workflow_activation::remove_from_cache::EvictionReason, FromPayloadsExt,
+                workflow_activation::remove_from_cache::EvictionReason,
+                FromPayloadsExt,
             },
             temporal::api::{
                 enums::v1::WorkflowTaskFailedCause,
@@ -511,6 +513,12 @@ pub mod coresdk {
             }
         }
 
+        impl workflow_activation_job::Variant {
+            pub fn is_local_activity_resolution(&self) -> bool {
+                matches!(self, workflow_activation_job::Variant::ResolveActivity(ra) if ra.is_local)
+            }
+        }
+
         impl Display for EvictionReason {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "{self:?}")
@@ -558,8 +566,8 @@ pub mod coresdk {
         impl Display for workflow_activation_job::Variant {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 match self {
-                    workflow_activation_job::Variant::StartWorkflow(_) => {
-                        write!(f, "StartWorkflow")
+                    workflow_activation_job::Variant::InitializeWorkflow(_) => {
+                        write!(f, "InitializeWorkflow")
                     }
                     workflow_activation_job::Variant::FireTimer(t) => {
                         write!(f, "FireTimer({})", t.seq)
@@ -577,7 +585,14 @@ pub mod coresdk {
                         write!(f, "SignalWorkflow")
                     }
                     workflow_activation_job::Variant::ResolveActivity(r) => {
-                        write!(f, "ResolveActivity({})", r.seq)
+                        write!(
+                            f,
+                            "ResolveActivity({}, {})",
+                            r.seq,
+                            r.result
+                                .as_ref()
+                                .unwrap_or_else(|| &ActivityResolution { status: None })
+                        )
                     }
                     workflow_activation_job::Variant::NotifyHasPatch(_) => {
                         write!(f, "NotifyHasPatch")
@@ -604,6 +619,28 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ActivityResolution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                match self.status {
+                    None => {
+                        write!(f, "None")
+                    }
+                    Some(activity_resolution::Status::Failed(_)) => {
+                        write!(f, "Failed")
+                    }
+                    Some(activity_resolution::Status::Completed(_)) => {
+                        write!(f, "Completed")
+                    }
+                    Some(activity_resolution::Status::Cancelled(_)) => {
+                        write!(f, "Cancelled")
+                    }
+                    Some(activity_resolution::Status::Backoff(_)) => {
+                        write!(f, "Backoff")
+                    }
+                }
+            }
+        }
+
         impl Display for QueryWorkflow {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(
@@ -631,14 +668,14 @@ pub mod coresdk {
             }
         }
 
-        /// Create a [StartWorkflow] job from corresponding event attributes
+        /// Create a [InitializeWorkflow] job from corresponding event attributes
         pub fn start_workflow_from_attribs(
             attrs: WorkflowExecutionStartedEventAttributes,
             workflow_id: String,
             randomness_seed: u64,
             start_time: Timestamp,
-        ) -> StartWorkflow {
-            StartWorkflow {
+        ) -> InitializeWorkflow {
+            InitializeWorkflow {
                 workflow_type: attrs.workflow_type.map(|wt| wt.name).unwrap_or_default(),
                 workflow_id,
                 arguments: Vec::from_payloads(attrs.input),
@@ -950,13 +987,17 @@ pub mod coresdk {
             }
         }
 
-        pub fn fail(run_id: impl Into<String>, failure: Failure) -> Self {
+        pub fn fail(
+            run_id: impl Into<String>,
+            failure: Failure,
+            cause: Option<WorkflowTaskFailedCause>,
+        ) -> Self {
             Self {
                 run_id: run_id.into(),
                 status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
-                        force_cause: WorkflowTaskFailedCause::Unspecified as i32,
+                        force_cause: cause.unwrap_or(WorkflowTaskFailedCause::Unspecified) as i32,
                     },
                 )),
             }
@@ -1959,60 +2000,60 @@ pub mod temporal {
                     pub fn event_type(&self) -> EventType {
                         // I just absolutely _love_ this
                         match self {
-                            Attributes::WorkflowExecutionStartedEventAttributes(_) => {EventType::WorkflowExecutionStarted}
-                            Attributes::WorkflowExecutionCompletedEventAttributes(_) => {EventType::WorkflowExecutionCompleted}
-                            Attributes::WorkflowExecutionFailedEventAttributes(_) => {EventType::WorkflowExecutionFailed}
-                            Attributes::WorkflowExecutionTimedOutEventAttributes(_) => {EventType::WorkflowExecutionTimedOut}
-                            Attributes::WorkflowTaskScheduledEventAttributes(_) => {EventType::WorkflowTaskScheduled}
-                            Attributes::WorkflowTaskStartedEventAttributes(_) => {EventType::WorkflowTaskStarted}
-                            Attributes::WorkflowTaskCompletedEventAttributes(_) => {EventType::WorkflowTaskCompleted}
-                            Attributes::WorkflowTaskTimedOutEventAttributes(_) => {EventType::WorkflowTaskTimedOut}
-                            Attributes::WorkflowTaskFailedEventAttributes(_) => {EventType::WorkflowTaskFailed}
-                            Attributes::ActivityTaskScheduledEventAttributes(_) => {EventType::ActivityTaskScheduled}
-                            Attributes::ActivityTaskStartedEventAttributes(_) => {EventType::ActivityTaskStarted}
-                            Attributes::ActivityTaskCompletedEventAttributes(_) => {EventType::ActivityTaskCompleted}
-                            Attributes::ActivityTaskFailedEventAttributes(_) => {EventType::ActivityTaskFailed}
-                            Attributes::ActivityTaskTimedOutEventAttributes(_) => {EventType::ActivityTaskTimedOut}
-                            Attributes::TimerStartedEventAttributes(_) => {EventType::TimerStarted}
-                            Attributes::TimerFiredEventAttributes(_) => {EventType::TimerFired}
-                            Attributes::ActivityTaskCancelRequestedEventAttributes(_) => {EventType::ActivityTaskCancelRequested}
-                            Attributes::ActivityTaskCanceledEventAttributes(_) => {EventType::ActivityTaskCanceled}
-                            Attributes::TimerCanceledEventAttributes(_) => {EventType::TimerCanceled}
-                            Attributes::MarkerRecordedEventAttributes(_) => {EventType::MarkerRecorded}
-                            Attributes::WorkflowExecutionSignaledEventAttributes(_) => {EventType::WorkflowExecutionSignaled}
-                            Attributes::WorkflowExecutionTerminatedEventAttributes(_) => {EventType::WorkflowExecutionTerminated}
-                            Attributes::WorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::WorkflowExecutionCancelRequested}
-                            Attributes::WorkflowExecutionCanceledEventAttributes(_) => {EventType::WorkflowExecutionCanceled}
-                            Attributes::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionInitiated}
-                            Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionFailed}
-                            Attributes::ExternalWorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::ExternalWorkflowExecutionCancelRequested}
-                            Attributes::WorkflowExecutionContinuedAsNewEventAttributes(_) => {EventType::WorkflowExecutionContinuedAsNew}
-                            Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(_) => {EventType::StartChildWorkflowExecutionInitiated}
-                            Attributes::StartChildWorkflowExecutionFailedEventAttributes(_) => {EventType::StartChildWorkflowExecutionFailed}
-                            Attributes::ChildWorkflowExecutionStartedEventAttributes(_) => {EventType::ChildWorkflowExecutionStarted}
-                            Attributes::ChildWorkflowExecutionCompletedEventAttributes(_) => {EventType::ChildWorkflowExecutionCompleted}
-                            Attributes::ChildWorkflowExecutionFailedEventAttributes(_) => {EventType::ChildWorkflowExecutionFailed}
-                            Attributes::ChildWorkflowExecutionCanceledEventAttributes(_) => {EventType::ChildWorkflowExecutionCanceled}
-                            Attributes::ChildWorkflowExecutionTimedOutEventAttributes(_) => {EventType::ChildWorkflowExecutionTimedOut}
-                            Attributes::ChildWorkflowExecutionTerminatedEventAttributes(_) => {EventType::ChildWorkflowExecutionTerminated}
-                            Attributes::SignalExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionInitiated}
-                            Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionFailed}
-                            Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => {EventType::ExternalWorkflowExecutionSignaled}
-                            Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => {EventType::UpsertWorkflowSearchAttributes}
-                            Attributes::WorkflowExecutionUpdateAdmittedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAdmitted}
-                            Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRejected}
-                            Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAccepted}
-                            Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => {EventType::WorkflowExecutionUpdateCompleted}
-                            Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => {EventType::WorkflowPropertiesModifiedExternally}
-                            Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => {EventType::ActivityPropertiesModifiedExternally}
-                            Attributes::WorkflowPropertiesModifiedEventAttributes(_) => {EventType::WorkflowPropertiesModified}
-                            Attributes::NexusOperationScheduledEventAttributes(_) => {EventType::NexusOperationScheduled}
-                            Attributes::NexusOperationStartedEventAttributes(_) => {EventType::NexusOperationStarted}
-                            Attributes::NexusOperationCompletedEventAttributes(_) => {EventType::NexusOperationCompleted}
-                            Attributes::NexusOperationFailedEventAttributes(_) => {EventType::NexusOperationFailed}
-                            Attributes::NexusOperationCanceledEventAttributes(_) => {EventType::NexusOperationCanceled}
-                            Attributes::NexusOperationTimedOutEventAttributes(_) => {EventType::NexusOperationTimedOut}
-                            Attributes::NexusOperationCancelRequestedEventAttributes(_) => {EventType::NexusOperationCancelRequested}
+                            Attributes::WorkflowExecutionStartedEventAttributes(_) => { EventType::WorkflowExecutionStarted }
+                            Attributes::WorkflowExecutionCompletedEventAttributes(_) => { EventType::WorkflowExecutionCompleted }
+                            Attributes::WorkflowExecutionFailedEventAttributes(_) => { EventType::WorkflowExecutionFailed }
+                            Attributes::WorkflowExecutionTimedOutEventAttributes(_) => { EventType::WorkflowExecutionTimedOut }
+                            Attributes::WorkflowTaskScheduledEventAttributes(_) => { EventType::WorkflowTaskScheduled }
+                            Attributes::WorkflowTaskStartedEventAttributes(_) => { EventType::WorkflowTaskStarted }
+                            Attributes::WorkflowTaskCompletedEventAttributes(_) => { EventType::WorkflowTaskCompleted }
+                            Attributes::WorkflowTaskTimedOutEventAttributes(_) => { EventType::WorkflowTaskTimedOut }
+                            Attributes::WorkflowTaskFailedEventAttributes(_) => { EventType::WorkflowTaskFailed }
+                            Attributes::ActivityTaskScheduledEventAttributes(_) => { EventType::ActivityTaskScheduled }
+                            Attributes::ActivityTaskStartedEventAttributes(_) => { EventType::ActivityTaskStarted }
+                            Attributes::ActivityTaskCompletedEventAttributes(_) => { EventType::ActivityTaskCompleted }
+                            Attributes::ActivityTaskFailedEventAttributes(_) => { EventType::ActivityTaskFailed }
+                            Attributes::ActivityTaskTimedOutEventAttributes(_) => { EventType::ActivityTaskTimedOut }
+                            Attributes::TimerStartedEventAttributes(_) => { EventType::TimerStarted }
+                            Attributes::TimerFiredEventAttributes(_) => { EventType::TimerFired }
+                            Attributes::ActivityTaskCancelRequestedEventAttributes(_) => { EventType::ActivityTaskCancelRequested }
+                            Attributes::ActivityTaskCanceledEventAttributes(_) => { EventType::ActivityTaskCanceled }
+                            Attributes::TimerCanceledEventAttributes(_) => { EventType::TimerCanceled }
+                            Attributes::MarkerRecordedEventAttributes(_) => { EventType::MarkerRecorded }
+                            Attributes::WorkflowExecutionSignaledEventAttributes(_) => { EventType::WorkflowExecutionSignaled }
+                            Attributes::WorkflowExecutionTerminatedEventAttributes(_) => { EventType::WorkflowExecutionTerminated }
+                            Attributes::WorkflowExecutionCancelRequestedEventAttributes(_) => { EventType::WorkflowExecutionCancelRequested }
+                            Attributes::WorkflowExecutionCanceledEventAttributes(_) => { EventType::WorkflowExecutionCanceled }
+                            Attributes::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes(_) => { EventType::RequestCancelExternalWorkflowExecutionInitiated }
+                            Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(_) => { EventType::RequestCancelExternalWorkflowExecutionFailed }
+                            Attributes::ExternalWorkflowExecutionCancelRequestedEventAttributes(_) => { EventType::ExternalWorkflowExecutionCancelRequested }
+                            Attributes::WorkflowExecutionContinuedAsNewEventAttributes(_) => { EventType::WorkflowExecutionContinuedAsNew }
+                            Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(_) => { EventType::StartChildWorkflowExecutionInitiated }
+                            Attributes::StartChildWorkflowExecutionFailedEventAttributes(_) => { EventType::StartChildWorkflowExecutionFailed }
+                            Attributes::ChildWorkflowExecutionStartedEventAttributes(_) => { EventType::ChildWorkflowExecutionStarted }
+                            Attributes::ChildWorkflowExecutionCompletedEventAttributes(_) => { EventType::ChildWorkflowExecutionCompleted }
+                            Attributes::ChildWorkflowExecutionFailedEventAttributes(_) => { EventType::ChildWorkflowExecutionFailed }
+                            Attributes::ChildWorkflowExecutionCanceledEventAttributes(_) => { EventType::ChildWorkflowExecutionCanceled }
+                            Attributes::ChildWorkflowExecutionTimedOutEventAttributes(_) => { EventType::ChildWorkflowExecutionTimedOut }
+                            Attributes::ChildWorkflowExecutionTerminatedEventAttributes(_) => { EventType::ChildWorkflowExecutionTerminated }
+                            Attributes::SignalExternalWorkflowExecutionInitiatedEventAttributes(_) => { EventType::SignalExternalWorkflowExecutionInitiated }
+                            Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => { EventType::SignalExternalWorkflowExecutionFailed }
+                            Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => { EventType::ExternalWorkflowExecutionSignaled }
+                            Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => { EventType::UpsertWorkflowSearchAttributes }
+                            Attributes::WorkflowExecutionUpdateAdmittedEventAttributes(_) => { EventType::WorkflowExecutionUpdateAdmitted }
+                            Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => { EventType::WorkflowExecutionUpdateRejected }
+                            Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => { EventType::WorkflowExecutionUpdateAccepted }
+                            Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => { EventType::WorkflowExecutionUpdateCompleted }
+                            Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => { EventType::WorkflowPropertiesModifiedExternally }
+                            Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => { EventType::ActivityPropertiesModifiedExternally }
+                            Attributes::WorkflowPropertiesModifiedEventAttributes(_) => { EventType::WorkflowPropertiesModified }
+                            Attributes::NexusOperationScheduledEventAttributes(_) => { EventType::NexusOperationScheduled }
+                            Attributes::NexusOperationStartedEventAttributes(_) => { EventType::NexusOperationStarted }
+                            Attributes::NexusOperationCompletedEventAttributes(_) => { EventType::NexusOperationCompleted }
+                            Attributes::NexusOperationFailedEventAttributes(_) => { EventType::NexusOperationFailed }
+                            Attributes::NexusOperationCanceledEventAttributes(_) => { EventType::NexusOperationCanceled }
+                            Attributes::NexusOperationTimedOutEventAttributes(_) => { EventType::NexusOperationTimedOut }
+                            Attributes::NexusOperationCancelRequestedEventAttributes(_) => { EventType::NexusOperationCancelRequested }
                         }
                     }
                 }

package/sdk-core/test-utils/src/lib.rs

@@ -73,11 +73,12 @@ pub const INTEG_USE_TLS_ENV_VAR: &str = "TEMPORAL_USE_TLS";
 pub const INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR: &str = "INTEG_TEMPORAL_DEV_SERVER_ON";
 /// This env var is set (to any value) if the test server is in use
 pub const INTEG_TEST_SERVER_USED_ENV_VAR: &str = "INTEG_TEST_SERVER_ON";
-
+pub static SEARCH_ATTR_TXT: &str = "CustomTextField";
+pub static SEARCH_ATTR_INT: &str = "CustomIntField";
 /// If set, turn export traces and metrics to the OTel collector at the given URL
-const OTEL_URL_ENV_VAR: &str = "TEMPORAL_INTEG_OTEL_URL";
+pub const OTEL_URL_ENV_VAR: &str = "TEMPORAL_INTEG_OTEL_URL";
 /// If set, enable direct scraping of prom metrics on the specified port
-const PROM_ENABLE_ENV_VAR: &str = "TEMPORAL_INTEG_PROM_PORT";
+pub const PROM_ENABLE_ENV_VAR: &str = "TEMPORAL_INTEG_PROM_PORT";
 #[macro_export]
 macro_rules! prost_dur {
     ($dur_call:ident $args:tt) => {

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

@@ -9,9 +9,12 @@ use std::{
 };
 use temporal_client::{Namespace, RetryConfig, WorkflowClientTrait, WorkflowService};
 use temporal_sdk_core_protos::temporal::api::{
-    cloud::cloudservice::v1::GetNamespaceRequest, workflowservice::v1::DescribeNamespaceRequest,
+    cloud::cloudservice::v1::GetNamespaceRequest,
+    workflowservice::v1::{DescribeNamespaceRequest, GetWorkflowExecutionHistoryRequest},
+};
+use temporal_sdk_core_test_utils::{
+    get_integ_server_options, init_integ_telem, CoreWfStarter, NAMESPACE,
 };
-use temporal_sdk_core_test_utils::{get_integ_server_options, CoreWfStarter, NAMESPACE};
 use tokio::{
     net::TcpListener,
     sync::{mpsc::UnboundedSender, oneshot},
@@ -121,6 +124,7 @@ impl NamedService for GenericService {
 
 #[tokio::test]
 async fn timeouts_respected_one_call_fake_server() {
+    init_integ_telem();
     let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
     let (header_tx, mut header_rx) = tokio::sync::mpsc::unbounded_channel();
 
@@ -155,8 +159,8 @@ async fn timeouts_respected_one_call_fake_server() {
     let mut client = opts.connect_no_namespace(None).await.unwrap();
 
     macro_rules! call_client {
-        ($client:ident, $trx:ident, $client_fn:ident) => {
-            let mut req = Request::new(Default::default());
+        ($client:ident, $trx:ident, $client_fn:ident, $msg:expr) => {
+            let mut req = Request::new($msg);
             req.set_timeout(Duration::from_millis(100));
             // Response is always error b/c empty body
             let _ = $client.$client_fn(req).await;
@@ -165,9 +169,34 @@ async fn timeouts_respected_one_call_fake_server() {
         };
     }
 
-    call_client!(client, header_rx, get_workflow_execution_history);
-    call_client!(client, header_rx, update_workflow_execution);
-    call_client!(client, header_rx, poll_workflow_execution_update);
+    call_client!(
+        client,
+        header_rx,
+        get_workflow_execution_history,
+        Default::default()
+    );
+    call_client!(
+        client,
+        header_rx,
+        get_workflow_execution_history,
+        GetWorkflowExecutionHistoryRequest {
+            // Ensure these calls when done long-poll style still respect timeout
+            wait_new_event: true,
+            ..Default::default()
+        }
+    );
+    call_client!(
+        client,
+        header_rx,
+        update_workflow_execution,
+        Default::default()
+    );
+    call_client!(
+        client,
+        header_rx,
+        poll_workflow_execution_update,
+        Default::default()
+    );
 
     // Shutdown the server
     shutdown_tx.send(()).unwrap();

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

@@ -85,7 +85,7 @@ async fn activity_heartbeat() {
                 variant: Some(workflow_activation_job::Variant::ResolveActivity(
                     ResolveActivity {seq, result: Some(ActivityResolution {
                     status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
-                     ..})}
+                     ..}),..}
                 )),
             },
         ] => {