@temporalio/core-bridge 1.11.6 → 1.11.8

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

@@ -47,25 +47,44 @@ pub(crate) enum InternalFlags {
         lang: BTreeSet<u32>,
         core_since_last_complete: HashSet<CoreInternalFlags>,
         lang_since_last_complete: HashSet<u32>,
+        last_sdk_name: String,
+        last_sdk_version: String,
+        sdk_name: String,
+        sdk_version: String,
     },
     Disabled,
 }
 
 impl InternalFlags {
-    pub(crate) fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
+    pub(crate) fn new(
+        server_capabilities: &get_system_info_response::Capabilities,
+        sdk_name: String,
+        sdk_version: String,
+    ) -> Self {
         match server_capabilities.sdk_metadata {
             true => Self::Enabled {
                 core: Default::default(),
                 lang: Default::default(),
                 core_since_last_complete: Default::default(),
                 lang_since_last_complete: Default::default(),
+                last_sdk_name: "".to_string(),
+                last_sdk_version: "".to_string(),
+                sdk_name,
+                sdk_version,
             },
             false => Self::Disabled,
         }
     }
 
     pub(crate) fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
-        if let Self::Enabled { core, lang, .. } = self {
+        if let Self::Enabled {
+            core,
+            lang,
+            last_sdk_name,
+            last_sdk_version,
+            ..
+        } = self
+        {
             if let Some(metadata) = e.sdk_metadata.as_ref() {
                 core.extend(
                     metadata
@@ -74,6 +93,12 @@ impl InternalFlags {
                         .map(|u| CoreInternalFlags::from_u32(*u)),
                 );
                 lang.extend(metadata.lang_used_flags.iter());
+                if !metadata.sdk_name.is_empty() {
+                    *last_sdk_name = metadata.sdk_name.clone();
+                }
+                if !metadata.sdk_version.is_empty() {
+                    *last_sdk_version = metadata.sdk_version.clone();
+                }
             }
         }
     }
@@ -133,6 +158,10 @@ impl InternalFlags {
                 lang_since_last_complete,
                 core,
                 lang,
+                last_sdk_name,
+                last_sdk_version,
+                sdk_name,
+                sdk_version,
             } => {
                 let core_newly_used: Vec<_> = core_since_last_complete
                     .iter()
@@ -146,11 +175,21 @@ impl InternalFlags {
                     .collect();
                 core.extend(core_since_last_complete.iter());
                 lang.extend(lang_since_last_complete.iter());
+                let sdk_name = if last_sdk_name != sdk_name {
+                    sdk_name.clone()
+                } else {
+                    "".to_string()
+                };
+                let sdk_version = if last_sdk_version != sdk_version {
+                    sdk_version.clone()
+                } else {
+                    "".to_string()
+                };
                 WorkflowTaskCompletedMetadata {
                     core_used_flags: core_newly_used,
                     lang_used_flags: lang_newly_used,
-                    sdk_name: "".to_string(),
-                    sdk_version: "".to_string(),
+                    sdk_name,
+                    sdk_version,
                 }
             }
             Self::Disabled => WorkflowTaskCompletedMetadata::default(),
@@ -186,9 +225,19 @@ mod tests {
     use super::*;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response::Capabilities;
 
+    impl Default for InternalFlags {
+        fn default() -> Self {
+            Self::Disabled
+        }
+    }
+
     #[test]
     fn disabled_in_capabilities_disables() {
-        let mut f = InternalFlags::new(&Capabilities::default());
+        let mut f = InternalFlags::new(
+            &Capabilities::default(),
+            "name".to_string(),
+            "ver".to_string(),
+        );
         f.add_lang_used([1]);
         f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
             sdk_metadata: Some(WorkflowTaskCompletedMetadata {
@@ -214,23 +263,29 @@ mod tests {
     }
 
     #[test]
-    fn only_writes_new_flags() {
-        let mut f = InternalFlags::new(&Capabilities {
-            sdk_metadata: true,
-            ..Default::default()
-        });
+    fn only_writes_new_flags_and_sdk_info() {
+        let mut f = InternalFlags::new(
+            &Capabilities {
+                sdk_metadata: true,
+                ..Default::default()
+            },
+            "name".to_string(),
+            "ver".to_string(),
+        );
         f.add_lang_used([1]);
         f.try_use(CoreInternalFlags::IdAndTypeDeterminismChecks, true);
         let gathered = f.gather_for_wft_complete();
         assert_matches!(gathered.core_used_flags.as_slice(), &[1]);
         assert_matches!(gathered.lang_used_flags.as_slice(), &[1]);
+        assert_matches!(gathered.sdk_name.as_str(), "name");
+        assert_matches!(gathered.sdk_version.as_str(), "ver");
 
         f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
             sdk_metadata: Some(WorkflowTaskCompletedMetadata {
                 core_used_flags: vec![2],
                 lang_used_flags: vec![2],
-                sdk_name: "".to_string(),
-                sdk_version: "".to_string(),
+                sdk_name: "name".to_string(),
+                sdk_version: "ver".to_string(),
             }),
             ..Default::default()
         });
@@ -239,5 +294,41 @@ mod tests {
         let gathered = f.gather_for_wft_complete();
         assert_matches!(gathered.core_used_flags.as_slice(), &[]);
         assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+        assert!(gathered.sdk_name.is_empty());
+        assert!(gathered.sdk_version.is_empty());
+
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata::default()),
+            ..Default::default()
+        });
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+        assert!(gathered.sdk_name.is_empty());
+        assert!(gathered.sdk_version.is_empty());
+
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                sdk_name: "other sdk".to_string(),
+                sdk_version: "other ver".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        });
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.sdk_name.as_str(), "name");
+        assert_matches!(gathered.sdk_version.as_str(), "ver");
+
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                sdk_name: "name".to_string(),
+                sdk_version: "ver2".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        });
+        let gathered = f.gather_for_wft_complete();
+        assert!(gathered.sdk_name.is_empty());
+        assert_matches!(gathered.sdk_version.as_str(), "ver");
     }
 }

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

@@ -50,19 +50,19 @@ pub use worker::{
 use crate::{
     replay::{HistoryForReplay, ReplayWorkerInput},
     telemetry::{
-        metrics::MetricsContext, remove_trace_subscriber_for_current_thread,
-        set_trace_subscriber_for_current_thread, telemetry_init, TelemetryInstance,
+        TelemetryInstance, metrics::MetricsContext, remove_trace_subscriber_for_current_thread,
+        set_trace_subscriber_for_current_thread, telemetry_init,
     },
     worker::client::WorkerClientBag,
 };
 use anyhow::bail;
 use futures_util::Stream;
 use std::sync::Arc;
-use temporal_client::{ConfiguredClient, TemporalServiceClientWithMetrics};
+use temporal_client::{ConfiguredClient, NamespacedClient, TemporalServiceClientWithMetrics};
 use temporal_sdk_core_api::{
-    errors::{CompleteActivityError, PollActivityError, PollWfError},
-    telemetry::TelemetryOptions,
     Worker as WorkerTrait,
+    errors::{CompleteActivityError, PollError},
+    telemetry::TelemetryOptions,
 };
 use temporal_sdk_core_protos::coresdk::ActivityHeartbeat;
 
@@ -90,9 +90,9 @@ where
         bail!("Passed in client is not bound to the same namespace as the worker");
     }
     if client.namespace() == "" {
-        bail!("Namespace cannot be empty");
+        bail!("Client namespace cannot be empty");
     }
-    let client_ident = client.get_options().identity.clone();
+    let client_ident = client.get_identity().to_owned();
     let sticky_q = sticky_q_name_for_worker(&client_ident, &worker_config);
     let client_bag = Arc::new(WorkerClientBag::new(
         client,
@@ -162,31 +162,39 @@ mod sealed {
     /// use-case was worker initialization.
     ///
     /// Needs to exist in this crate to avoid blanket impl conflicts.
-    pub struct AnyClient(Box<ConfiguredClient<TemporalServiceClientWithMetrics>>);
+    pub struct AnyClient {
+        pub(crate) inner: Box<ConfiguredClient<TemporalServiceClientWithMetrics>>,
+    }
     impl AnyClient {
         pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClientWithMetrics>> {
-            self.0
+            self.inner
         }
     }
 
     impl From<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>> for AnyClient {
         fn from(c: RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>) -> Self {
-            Self(Box::new(c.into_inner()))
+            Self {
+                inner: Box::new(c.into_inner()),
+            }
         }
     }
     impl From<RetryClient<Client>> for AnyClient {
         fn from(c: RetryClient<Client>) -> Self {
-            Self(Box::new(c.into_inner().into_inner()))
+            Self {
+                inner: Box::new(c.into_inner().into_inner()),
+            }
         }
     }
     impl From<Arc<RetryClient<Client>>> for AnyClient {
         fn from(c: Arc<RetryClient<Client>>) -> Self {
-            Self(Box::new(c.get_client().inner().clone()))
+            Self {
+                inner: Box::new(c.get_client().inner().clone()),
+            }
         }
     }
     impl From<ConfiguredClient<TemporalServiceClientWithMetrics>> for AnyClient {
         fn from(c: ConfiguredClient<TemporalServiceClientWithMetrics>) -> Self {
-            Self(Box::new(c))
+            Self { inner: Box::new(c) }
         }
     }
 }

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

@@ -1,28 +1,35 @@
 mod poll_buffer;
 
 pub(crate) use poll_buffer::{
-    new_activity_task_buffer, new_workflow_task_buffer, WorkflowTaskPoller,
+    WorkflowTaskPoller, new_activity_task_buffer, new_nexus_task_buffer, new_workflow_task_buffer,
 };
 pub use temporal_client::{
     Client, ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryClient, RetryConfig,
     TlsConfig, WorkflowClientTrait,
 };
 
-use crate::abstractions::OwnedMeteredSemPermit;
+use crate::{
+    abstractions::{OwnedMeteredSemPermit, TrackedOwnedMeteredSemPermit},
+    telemetry::metrics::MetricsContext,
+};
+use anyhow::{anyhow, bail};
+use futures_util::{Stream, stream};
+use std::{fmt::Debug, marker::PhantomData};
+use temporal_sdk_core_api::worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind};
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
-    PollActivityTaskQueueResponse, PollWorkflowTaskQueueResponse,
+    PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
 };
+use tokio::select;
+use tokio_util::sync::CancellationToken;
 
 #[cfg(test)]
 use futures_util::Future;
 #[cfg(test)]
 pub(crate) use poll_buffer::MockPermittedPollBuffer;
-use temporal_sdk_core_api::worker::{ActivitySlotKind, WorkflowSlotKind};
 
 pub(crate) type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
-/// A trait for things that poll the server. Hides complexity of concurrent polling or polling
-/// on sticky/nonsticky queues simultaneously.
+/// A trait for things that long poll the server.
 #[cfg_attr(test, mockall::automock)]
 #[cfg_attr(test, allow(unused))]
 #[async_trait::async_trait]
@@ -45,6 +52,10 @@ pub(crate) type BoxedActPoller = BoxedPoller<(
     PollActivityTaskQueueResponse,
     OwnedMeteredSemPermit<ActivitySlotKind>,
 )>;
+pub(crate) type BoxedNexusPoller = BoxedPoller<(
+    PollNexusTaskQueueResponse,
+    OwnedMeteredSemPermit<NexusSlotKind>,
+)>;
 
 #[async_trait::async_trait]
 impl<T> Poller<T> for Box<dyn Poller<T> + Send + Sync>
@@ -85,3 +96,186 @@ mockall::mock! {
             where Self: 'a;
     }
 }
+
+#[derive(Debug)]
+pub(crate) struct PermittedTqResp<T: ValidatableTask> {
+    pub(crate) permit: OwnedMeteredSemPermit<T::SlotKind>,
+    pub(crate) resp: T,
+}
+
+#[derive(Debug)]
+pub(crate) struct TrackedPermittedTqResp<T: ValidatableTask> {
+    pub(crate) permit: TrackedOwnedMeteredSemPermit<T::SlotKind>,
+    pub(crate) resp: T,
+}
+
+pub(crate) trait ValidatableTask:
+    Debug + Default + PartialEq + Send + Sync + 'static
+{
+    type SlotKind: SlotKind;
+
+    fn validate(&self) -> Result<(), anyhow::Error>;
+    fn task_name() -> &'static str;
+}
+
+pub(crate) struct TaskPollerStream<P, T>
+where
+    P: Poller<(T, OwnedMeteredSemPermit<T::SlotKind>)>,
+    T: ValidatableTask,
+{
+    poller: P,
+    metrics: MetricsContext,
+    metrics_no_task: fn(&MetricsContext),
+    shutdown_token: CancellationToken,
+    poller_was_shutdown: bool,
+    _phantom: PhantomData<T>,
+}
+
+impl<P, T> TaskPollerStream<P, T>
+where
+    P: Poller<(T, OwnedMeteredSemPermit<T::SlotKind>)>,
+    T: ValidatableTask,
+{
+    pub(crate) fn new(
+        poller: P,
+        metrics: MetricsContext,
+        metrics_no_task: fn(&MetricsContext),
+        shutdown_token: CancellationToken,
+    ) -> Self {
+        Self {
+            poller,
+            metrics,
+            metrics_no_task,
+            shutdown_token,
+            poller_was_shutdown: false,
+            _phantom: PhantomData,
+        }
+    }
+
+    fn into_stream(self) -> impl Stream<Item = Result<PermittedTqResp<T>, tonic::Status>> {
+        stream::unfold(self, |mut state| async move {
+            loop {
+                let poll = async {
+                    loop {
+                        return match state.poller.poll().await {
+                            Some(Ok((task, permit))) => {
+                                if task == Default::default() {
+                                    // We get the default proto in the event that the long poll
+                                    // times out.
+                                    debug!("Poll {} task timeout", T::task_name());
+                                    (state.metrics_no_task)(&state.metrics);
+                                    continue;
+                                }
+
+                                if let Err(e) = task.validate() {
+                                    warn!(
+                                        "Received invalid {} task ({}): {:?}",
+                                        T::task_name(),
+                                        e,
+                                        &task
+                                    );
+                                    return Some(Err(tonic::Status::invalid_argument(
+                                        e.to_string(),
+                                    )));
+                                }
+
+                                Some(Ok(PermittedTqResp { resp: task, permit }))
+                            }
+                            Some(Err(e)) => {
+                                warn!(error=?e, "Error while polling for {} tasks", T::task_name());
+                                Some(Err(e))
+                            }
+                            // If poller returns None, it's dead, thus we also return None to
+                            // terminate this stream.
+                            None => None,
+                        };
+                    }
+                };
+                if state.poller_was_shutdown {
+                    return poll.await.map(|res| (res, state));
+                }
+                select! {
+                    biased;
+
+                    _ = state.shutdown_token.cancelled() => {
+                        state.poller.notify_shutdown();
+                        state.poller_was_shutdown = true;
+                        continue;
+                    }
+                    res = poll => {
+                        return res.map(|res| (res, state));
+                    }
+                }
+            }
+        })
+    }
+}
+
+impl ValidatableTask for PollActivityTaskQueueResponse {
+    type SlotKind = ActivitySlotKind;
+
+    fn validate(&self) -> Result<(), anyhow::Error> {
+        if self.task_token.is_empty() {
+            return Err(anyhow!("missing task token"));
+        }
+        Ok(())
+    }
+
+    fn task_name() -> &'static str {
+        "activity"
+    }
+}
+
+pub(crate) fn new_activity_task_poller(
+    poller: BoxedActPoller,
+    metrics: MetricsContext,
+    shutdown_token: CancellationToken,
+) -> impl Stream<Item = Result<PermittedTqResp<PollActivityTaskQueueResponse>, tonic::Status>> {
+    TaskPollerStream::new(
+        poller,
+        metrics,
+        MetricsContext::act_poll_timeout,
+        shutdown_token,
+    )
+    .into_stream()
+}
+
+impl ValidatableTask for PollNexusTaskQueueResponse {
+    type SlotKind = NexusSlotKind;
+
+    fn validate(&self) -> Result<(), anyhow::Error> {
+        if self.task_token.is_empty() {
+            bail!("missing task token");
+        } else if self.request.is_none() {
+            bail!("missing request field");
+        } else if self
+            .request
+            .as_ref()
+            .expect("just request exists")
+            .variant
+            .is_none()
+        {
+            bail!("missing request variant");
+        }
+        Ok(())
+    }
+
+    fn task_name() -> &'static str {
+        "nexus"
+    }
+}
+
+pub(crate) type NexusPollItem = Result<PermittedTqResp<PollNexusTaskQueueResponse>, tonic::Status>;
+pub(crate) fn new_nexus_task_poller(
+    poller: BoxedNexusPoller,
+    metrics: MetricsContext,
+    shutdown_token: CancellationToken,
+) -> impl Stream<Item = NexusPollItem> {
+    TaskPollerStream::new(
+        poller,
+        metrics,
+        MetricsContext::nexus_poll_timeout,
+        shutdown_token,
+    )
+    .into_stream()
+}

package/sdk-core/core/src/pollers/poll_buffer.rs

@@ -1,29 +1,30 @@
 use crate::{
-    abstractions::{dbg_panic, MeteredPermitDealer, OwnedMeteredSemPermit},
+    abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit, dbg_panic},
     pollers::{self, Poller},
     worker::client::WorkerClient,
 };
-use futures_util::{future::BoxFuture, stream::FuturesUnordered, FutureExt, StreamExt};
+use futures_util::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered};
 use governor::{Quota, RateLimiter};
 use std::{
     fmt::Debug,
     future::Future,
     sync::{
-        atomic::{AtomicBool, AtomicUsize, Ordering},
         Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering},
     },
     time::Duration,
 };
-use temporal_sdk_core_api::worker::{ActivitySlotKind, SlotKind, WorkflowSlotKind};
+use temporal_sdk_core_api::worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind};
 use temporal_sdk_core_protos::temporal::api::{
     taskqueue::v1::TaskQueue,
-    workflowservice::v1::{PollActivityTaskQueueResponse, PollWorkflowTaskQueueResponse},
+    workflowservice::v1::{
+        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
+    },
 };
 use tokio::{
     sync::{
-        broadcast,
-        mpsc::{unbounded_channel, UnboundedReceiver},
-        Mutex,
+        Mutex, broadcast,
+        mpsc::{UnboundedReceiver, unbounded_channel},
     },
     task::JoinHandle,
 };
@@ -297,6 +298,29 @@ pub(crate) fn new_activity_task_buffer(
     )
 }
 
+pub(crate) type PollNexusTaskBuffer = LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind>;
+pub(crate) fn new_nexus_task_buffer(
+    client: Arc<dyn WorkerClient>,
+    task_queue: String,
+    concurrent_pollers: usize,
+    semaphore: MeteredPermitDealer<NexusSlotKind>,
+    shutdown: CancellationToken,
+    num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
+) -> PollNexusTaskBuffer {
+    LongPollBuffer::new(
+        move || {
+            let client = client.clone();
+            let task_queue = task_queue.clone();
+            async move { client.poll_nexus_task(task_queue).await }
+        },
+        semaphore,
+        concurrent_pollers,
+        shutdown,
+        num_pollers_handler,
+        None::<fn() -> BoxFuture<'static, ()>>,
+    )
+}
+
 #[cfg(test)]
 #[derive(derive_more::Constructor)]
 pub(crate) struct MockPermittedPollBuffer<PT, SK: SlotKind> {

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

@@ -1,9 +1,9 @@
 pub(crate) mod protocol_messages;
 
 use crate::{
-    protosext::protocol_messages::IncomingProtocolMessage,
-    worker::{LocalActivityExecutionResult, LEGACY_QUERY_ID},
     CompleteActivityError, TaskToken,
+    protosext::protocol_messages::IncomingProtocolMessage,
+    worker::{LEGACY_QUERY_ID, LocalActivityExecutionResult},
 };
 use anyhow::anyhow;
 use itertools::Itertools;
@@ -23,11 +23,11 @@ use temporal_sdk_core_protos::{
         },
         external_data::LocalActivityMarkerData,
         workflow_activation::{
-            query_to_job, workflow_activation_job, QueryWorkflow, WorkflowActivation,
-            WorkflowActivationJob,
+            QueryWorkflow, WorkflowActivation, WorkflowActivationJob, query_to_job,
+            workflow_activation_job,
         },
         workflow_commands::{
-            query_result, ActivityCancellationType, QueryResult, ScheduleLocalActivity,
+            ActivityCancellationType, QueryResult, ScheduleLocalActivity, query_result,
         },
         workflow_completion,
     },
@@ -35,7 +35,7 @@ use temporal_sdk_core_protos::{
         common::v1::{Payload, RetryPolicy, WorkflowExecution},
         enums::v1::EventType,
         failure::v1::Failure,
-        history::v1::{history_event, History, HistoryEvent, MarkerRecordedEventAttributes},
+        history::v1::{History, HistoryEvent, MarkerRecordedEventAttributes, history_event},
         query::v1::WorkflowQuery,
         workflowservice::v1::PollWorkflowTaskQueueResponse,
     },
@@ -400,7 +400,7 @@ impl ValidScheduleLA {
                 return Err(anyhow!(
                     "One or both of schedule_to_close or start_to_close timeouts must be set for \
                      local activities"
-                ))
+                ));
             }
         };
         let retry_policy = v.retry_policy.unwrap_or_default();

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

@@ -2,8 +2,8 @@ use anyhow::{anyhow, bail};
 use std::collections::HashMap;
 use temporal_sdk_core_protos::temporal::api::{
     common::v1::Payload,
-    history::v1::{history_event, HistoryEvent},
-    protocol::v1::{message::SequencingId, Message},
+    history::v1::{HistoryEvent, history_event},
+    protocol::v1::{Message, message::SequencingId},
     update,
 };
 

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

@@ -3,21 +3,23 @@
 //! users during testing.
 
 use crate::{
+    Worker,
     worker::{
-        client::mocks::{mock_manual_workflow_client, MockManualWorkerClient},
         PostActivateHookData,
+        client::mocks::{MockManualWorkerClient, mock_manual_workflow_client},
     },
-    Worker,
 };
 use futures_util::{FutureExt, Stream, StreamExt};
 use parking_lot::Mutex;
-use std::sync::OnceLock;
 use std::{
     pin::Pin,
-    sync::Arc,
+    sync::{Arc, OnceLock},
     task::{Context, Poll},
 };
 use temporal_sdk_core_api::worker::WorkerConfig;
+pub use temporal_sdk_core_protos::{
+    DEFAULT_WORKFLOW_TYPE, HistoryInfo, TestHistoryBuilder, default_wes_attribs,
+};
 use temporal_sdk_core_protos::{
     coresdk::workflow_activation::remove_from_cache::EvictionReason,
     temporal::api::{
@@ -28,10 +30,7 @@ use temporal_sdk_core_protos::{
         },
     },
 };
-pub use temporal_sdk_core_protos::{
-    default_wes_attribs, HistoryInfo, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
-};
-use tokio::sync::{mpsc, mpsc::UnboundedSender, Mutex as TokioMutex};
+use tokio::sync::{Mutex as TokioMutex, mpsc, mpsc::UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tokio_util::sync::CancellationToken;
 
@@ -202,7 +201,7 @@ impl Historator {
     /// we're ready to replay the next history, or whatever else.
     pub(crate) fn get_post_activate_hook(
         &self,
-    ) -> impl Fn(&Worker, PostActivateHookData) + Send + Sync {
+    ) -> impl Fn(&Worker, PostActivateHookData) + Send + Sync + use<> {
         let done_tx = self.replay_done_tx.clone();
         move |worker, data| {
             if !data.replaying {