@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -2,10 +2,12 @@ use crate::{
     abstractions::{ActiveCounter, MeteredPermitDealer, OwnedMeteredSemPermit, dbg_panic},
     pollers::{self, Poller},
     worker::{
-        WFTPollerShared,
+        ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WFTPollerShared,
+        WorkflowSlotKind,
         client::{PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient},
     },
 };
+use backoff::{SystemClock, backoff::Backoff, exponential::ExponentialBackoff};
 use crossbeam_utils::atomic::AtomicCell;
 use futures_util::{FutureExt, StreamExt, future::BoxFuture};
 use governor::{Quota, RateLimiter};
@@ -22,15 +24,11 @@ use std::{
 use temporalio_client::{
     ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, request_extensions::NoRetryOnMatching,
 };
-use temporalio_common::{
-    protos::temporal::api::{
-        taskqueue::v1::PollerScalingDecision,
-        workflowservice::v1::{
-            PollActivityTaskQueueResponse, PollNexusTaskQueueResponse,
-            PollWorkflowTaskQueueResponse,
-        },
+use temporalio_common::protos::temporal::api::{
+    taskqueue::v1::PollerScalingDecision,
+    workflowservice::v1::{
+        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
     },
-    worker::{ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WorkflowSlotKind},
 };
 use tokio::{
     sync::{
@@ -79,6 +77,7 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: WorkflowTaskOptions,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let is_sticky = sticky_queue.is_some();
         let poll_scaler = PollScaler::new(
@@ -141,6 +140,7 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
             poll_scaler,
             pre_permit_delay,
             post_poll_fn,
+            graceful_poll_shutdown,
         )
     }
 }
@@ -156,6 +156,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: ActivityTaskOptions,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let pre_permit_delay = options
             .max_worker_acts_per_second
@@ -208,6 +209,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
             poll_scaler,
             pre_permit_delay,
             None::<fn(&PollActivityTaskQueueResponse)>,
+            graceful_poll_shutdown,
         )
     }
 }
@@ -223,6 +225,7 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
         send_heartbeat: bool,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let no_retry = if matches!(poller_behavior, PollerBehavior::Autoscaling { .. }) {
             Some(NoRetryOnMatching {
@@ -259,10 +262,20 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
             ),
             None::<fn() -> BoxFuture<'static, ()>>,
             None::<fn(&PollNexusTaskQueueResponse)>,
+            graceful_poll_shutdown,
         )
     }
 }
 
+// Simple way to test this w/o plumbing options through. This will be removed after
+// the proper server implementation for terminating polls on worker shutdown exists.
+#[cfg(test)]
+use std::cell::RefCell;
+#[cfg(test)]
+thread_local! {
+    static POLL_SHUTDOWN_INTERRUPT: RefCell<Option<Duration>> = RefCell::default();
+}
+
 impl<T, SK> LongPollBuffer<T, SK>
 where
     T: TaskPollerResult + Send + Debug + 'static,
@@ -275,6 +288,7 @@ where
         mut poll_scaler: PollScaler<F>,
         pre_permit_delay: Option<impl Fn() -> DelayFut + Send + Sync + 'static>,
         post_poll_fn: Option<impl Fn(&T) + Send + Sync + 'static>,
+        graceful_shutdown: Arc<AtomicBool>,
     ) -> Self
     where
         FT: Future<Output = pollers::Result<T>> + Send,
@@ -282,11 +296,18 @@ where
         F: Fn(usize) + Send + Sync + 'static,
     {
         let (tx, rx) = unbounded_channel();
-        let (starter, wait_for_start) = broadcast::channel(1);
+        let (starter, mut wait_for_start) = broadcast::channel(1);
         let pf = Arc::new(poll_fn);
         let post_pf = Arc::new(post_poll_fn);
-        let mut wait_for_start = wait_for_start.resubscribe();
         let shutdown_clone = shutdown.clone();
+        #[cfg(test)]
+        let poll_shutdown_interrupt_wait = POLL_SHUTDOWN_INTERRUPT.with(|v| *v.borrow());
+        #[cfg(not(test))]
+        let poll_shutdown_interrupt_wait =
+            std::env::var("TEMPORAL_POLL_SHUTDOWN_INTERRUPT_WAIT_MS")
+                .ok()
+                .and_then(|s| s.parse::<u64>().ok())
+                .map(Duration::from_millis);
 
         let poller_task = tokio::spawn(
             async move {
@@ -338,18 +359,38 @@ where
                         } else {
                             None
                         };
+                    let graceful_shutdown = graceful_shutdown.clone();
                     let poll_task = tokio::spawn(async move {
-                        let r = tokio::select! {
-                            r = pf(timeout_override) => r,
-                            _ = shutdown.cancelled() => return,
+                        let shutdown_clone = shutdown.clone();
+
+                        let r = if graceful_shutdown.load(Ordering::Relaxed) {
+                            pf(timeout_override).await
+                        } else {
+                            let poll_interruptor = shutdown.cancelled().then(|_| async move {
+                                if let Some(w) = poll_shutdown_interrupt_wait {
+                                    tokio::time::sleep(w).await;
+                                }
+                            });
+                            tokio::select! {
+                                r = pf(timeout_override) => r,
+                                _ = poll_interruptor => return,
+                            }
                         };
-                        drop(active_guard);
                         if let Ok(r) = &r
                             && let Some(ppf) = post_pf.as_ref()
                         {
                             ppf(r);
                         }
-                        if report_handle.poll_result(&r) {
+                        let (should_forward, backoff_duration) = report_handle.poll_result(&r);
+                        if let Some(duration) = backoff_duration {
+                            // Apply backoff BEFORE dropping active_guard to prevent next poll from starting
+                            tokio::select! {
+                                _ = tokio::time::sleep(duration) => return,
+                                _ = shutdown_clone.cancelled() => (),
+                            };
+                        }
+                        drop(active_guard);
+                        if should_forward {
                             let _ = tx.send(r.map(|r| (r, permit)));
                         }
                     });
@@ -463,6 +504,28 @@ where
             ingested_last_period: Default::default(),
             scale_up_allowed: AtomicBool::new(true),
             last_successful_poll_time,
+            exponential_backoff: parking_lot::Mutex::new(ExponentialBackoff {
+                // Copied from RetryOptions::task_poll_retry_policy()
+                current_interval: Duration::from_millis(200),
+                initial_interval: Duration::from_millis(200),
+                randomization_factor: 0.2,
+                multiplier: 2.0,
+                max_interval: Duration::from_secs(10),
+                max_elapsed_time: None,
+                clock: SystemClock::default(),
+                start_time: std::time::Instant::now(),
+            }),
+            resource_exhausted_backoff: parking_lot::Mutex::new(ExponentialBackoff {
+                // Copied from RetryOptions::throttle_retry_policy()
+                current_interval: Duration::from_secs(1),
+                initial_interval: Duration::from_secs(1),
+                randomization_factor: 0.2,
+                multiplier: 2.0,
+                max_interval: Duration::from_secs(10),
+                max_elapsed_time: None,
+                clock: SystemClock::default(),
+                start_time: std::time::Instant::now(),
+            }),
         });
         let rhc = report_handle.clone();
         let ingestor_task = if behavior.is_autoscaling() {
@@ -526,18 +589,32 @@ struct PollScalerReportHandle {
     ingested_last_period: AtomicUsize,
     scale_up_allowed: AtomicBool,
     last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+
+    // Exponential backoff for normal errors and resource exhausted errors
+    exponential_backoff: parking_lot::Mutex<ExponentialBackoff<SystemClock>>,
+    resource_exhausted_backoff: parking_lot::Mutex<ExponentialBackoff<SystemClock>>,
 }
 
 impl PollScalerReportHandle {
-    /// Returns true if the response should be passed on, false if it should be swallowed
-    fn poll_result(&self, res: &Result<impl TaskPollerResult, tonic::Status>) -> bool {
+    /// Returns (should_forward, backoff_duration)
+    /// - should_forward: true if the response should be passed on, false if it should be swallowed
+    /// - backoff_duration: Some(duration) if we should sleep before the next poll
+    fn poll_result(
+        &self,
+        res: &Result<impl TaskPollerResult, tonic::Status>,
+    ) -> (bool, Option<Duration>) {
         match res {
             Ok(res) => {
                 self.last_successful_poll_time
                     .store(Some(SystemTime::now()));
+
+                // Reset backoff on successful poll
+                self.exponential_backoff.lock().reset();
+                self.resource_exhausted_backoff.lock().reset();
+
                 if let PollerBehavior::SimpleMaximum(_) = self.behavior {
                     // We don't do auto-scaling with the simple max
-                    return true;
+                    return (true, None);
                 }
                 if !res.is_empty() {
                     self.ingested_this_period.fetch_add(1, Ordering::Relaxed);
@@ -572,30 +649,36 @@ impl PollScalerReportHandle {
             }
             Err(e) => {
                 if matches!(self.behavior, PollerBehavior::Autoscaling { .. }) {
-                    // We should only react to errors in autoscaling mode if we saw a scaling
-                    // decision
+                    // Follow the same backoff logic as the retry client
+                    let mut backoff_duration = self.exponential_backoff.lock().next_backoff();
+                    if e.code() == Code::ResourceExhausted {
+                        backoff_duration = self.resource_exhausted_backoff.lock().next_backoff();
+                    };
+
+                    // Only propagate errors out if they weren't because of the short-circuiting
+                    // logic. IE: We don't want to fail callers because we said we wanted to know
+                    // about ResourceExhausted errors, but we haven't seen a scaling decision yet,
+                    // so we're not reacting to errors, only propagating them.
+                    let should_forward = !e
+                        .metadata()
+                        .contains_key(ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT);
+
+                    // We should only react to errors in autoscaling mode if we saw a scaling decision
                     if self.ever_saw_scaling_decision.load(Ordering::Relaxed) {
                         debug!("Got error from server while polling: {:?}", e);
                         if e.code() == Code::ResourceExhausted {
                             // Scale down significantly for resource exhaustion
                             self.change_target(usize::saturating_div, 2);
                         } else {
-                            // Other codes that would normally have made us back off briefly can
-                            // reclaim this poller
+                            // Other codes that would normally have made us back off briefly can reclaim this poller
                             self.change_target(usize::saturating_sub, 1);
                         }
                     }
-                    // Only propagate errors out if they weren't because of the short-circuiting
-                    // logic. IE: We don't want to fail callers because we said we wanted to know
-                    // about ResourceExhausted errors, but we haven't seen a scaling decision yet,
-                    // so we're not reacting to errors, only propagating them.
-                    return !e
-                        .metadata()
-                        .contains_key(ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT);
+                    return (should_forward, backoff_duration);
                 }
             }
         }
-        true
+        (true, None)
     }
 
     #[inline]
@@ -740,8 +823,9 @@ mod tests {
         worker::client::mocks::mock_manual_worker_client,
     };
     use futures_util::FutureExt;
+    use rstest::rstest;
     use std::time::Duration;
-    use tokio::select;
+    use tokio::{select, sync::Notify};
 
     #[tokio::test]
     async fn only_polls_once_with_1_poller() {
@@ -769,6 +853,7 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         );
 
         // Poll a bunch of times, "interrupting" it each time, we should only actually have polled
@@ -825,10 +910,304 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(1)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         );
 
         // Should not see error, unwraps should get empty response
         pb.poll().await.unwrap().unwrap();
         pb.shutdown().await;
     }
+
+    #[tokio::test]
+    async fn poll_shutdown_waits_interrupt_period_before_cancelling() {
+        POLL_SHUTDOWN_INTERRUPT.with(|v| {
+            *v.borrow_mut() = Some(Duration::from_millis(200));
+        });
+
+        let mut mock_client = mock_manual_worker_client();
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+
+        let second_task_complete = Arc::new(Notify::new());
+        let second_task_complete_clone = second_task_complete.clone();
+        let third_task_complete = Arc::new(Notify::new());
+        let third_task_complete_clone = third_task_complete.clone();
+
+        let second_started = Arc::new(Notify::new());
+        let second_started_clone = second_started.clone();
+        let third_started = Arc::new(Notify::new());
+        let third_started_clone = third_started.clone();
+
+        mock_client
+            .expect_poll_workflow_task()
+            .returning(move |_, _| {
+                let count = call_count_clone.fetch_add(1, Ordering::SeqCst);
+                let second_complete = second_task_complete_clone.clone();
+                let third_complete = third_task_complete_clone.clone();
+                let second_started = second_started_clone.clone();
+                let third_started = third_started_clone.clone();
+
+                async move {
+                    match count {
+                        0 => Ok(PollWorkflowTaskQueueResponse {
+                            task_token: vec![1],
+                            ..Default::default()
+                        }),
+                        1 => {
+                            second_started.notify_one();
+                            second_complete.notified().await;
+                            Ok(PollWorkflowTaskQueueResponse {
+                                task_token: vec![2],
+                                ..Default::default()
+                            })
+                        }
+                        _ => {
+                            third_started.notify_one();
+                            third_complete.notified().await;
+                            Ok(PollWorkflowTaskQueueResponse {
+                                task_token: vec![3],
+                                ..Default::default()
+                            })
+                        }
+                    }
+                }
+                .boxed()
+            });
+
+        let shutdown_token = CancellationToken::new();
+        let pb = LongPollBuffer::new_workflow_task(
+            Arc::new(mock_client),
+            "sometq".to_string(),
+            None,
+            PollerBehavior::SimpleMaximum(3),
+            fixed_size_permit_dealer(10),
+            shutdown_token.clone(),
+            None::<fn(usize)>,
+            WorkflowTaskOptions {
+                wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
+            },
+            Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
+        );
+
+        let first_task = pb.poll().await.expect("Should get first task");
+        assert!(first_task.is_ok());
+        assert_eq!(first_task.unwrap().0.task_token, vec![1]);
+
+        // Wait for both second and third polls to start
+        second_started.notified().await;
+        third_started.notified().await;
+
+        // Now both polls 2 and 3 are in progress. Trigger shutdown.
+        let shutdown_time = std::time::Instant::now();
+        shutdown_token.cancel();
+
+        // Immediately unlock the second task so it completes quickly (within interrupt wait)
+        second_task_complete.notify_one();
+
+        // Second task should be received because it completes within the interrupt wait period
+        let (task, _) = pb.poll().await.unwrap().unwrap();
+        assert_eq!(task.task_token, vec![2]);
+
+        // Don't notify third_task_complete - the third poll will wait for the interrupt period
+        // and then be interrupted. Should return None.
+        let third_task_result = pb.poll().await;
+        let elapsed = shutdown_time.elapsed();
+
+        assert!(
+            third_task_result.is_none(),
+            "Third task should not be received - poll should be interrupted after interrupt period"
+        );
+
+        // Total elapsed time should be at least the interrupt wait (200ms), but not significantly
+        // longer.
+        assert!(
+            elapsed >= Duration::from_millis(200),
+            "Should wait at least the interrupt period. Elapsed: {elapsed:?}",
+        );
+        assert!(
+            elapsed < Duration::from_secs(1),
+            "Should not wait too long. Elapsed: {elapsed:?}",
+        );
+
+        // Clean up
+        POLL_SHUTDOWN_INTERRUPT.with(|v| {
+            *v.borrow_mut() = None;
+        });
+    }
+
+    #[rstest]
+    #[case::resource_exhausted(Code::ResourceExhausted)]
+    #[case::internal(Code::Internal)]
+    #[tokio::test]
+    async fn autoscaler_applies_backoff_on_errors(#[case] error_code: Code) {
+        use temporalio_common::protos::temporal::api::taskqueue::v1::PollerScalingDecision;
+
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+        let first_poll_done = Arc::new(AtomicBool::new(false));
+        let first_poll_done_clone = first_poll_done.clone();
+
+        let mut mock_client = mock_manual_worker_client();
+        mock_client
+            .expect_poll_workflow_task()
+            .returning(move |_, _| {
+                call_count_clone.fetch_add(1, Ordering::SeqCst);
+                let first_done = first_poll_done_clone.clone();
+                async move {
+                    // First poll: return empty response with scaling decision
+                    // This sets ever_saw_scaling_decision to true
+                    if !first_done.swap(true, Ordering::SeqCst) {
+                        Ok(PollWorkflowTaskQueueResponse {
+                            task_token: vec![], // Empty poll
+                            poller_scaling_decision: Some(PollerScalingDecision {
+                                // Aggressively scale up to max
+                                poll_request_delta_suggestion: 0,
+                            }),
+                            ..Default::default()
+                        })
+                    } else {
+                        // All subsequent polls fail with a grpc error
+                        Err(tonic::Status::new(
+                            error_code,
+                            format!("simulated grpc error {error_code}"),
+                        ))
+                    }
+                }
+                .boxed()
+            });
+
+        let pb = Arc::new(LongPollBuffer::new_workflow_task(
+            Arc::new(mock_client),
+            "sometq".to_string(),
+            None,
+            PollerBehavior::Autoscaling {
+                minimum: 5,
+                maximum: 100,
+                initial: 10,
+            },
+            fixed_size_permit_dealer(10),
+            CancellationToken::new(),
+            None::<fn(usize)>,
+            WorkflowTaskOptions {
+                wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
+            },
+            Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
+        ));
+
+        // Trigger the first poll to initialize and get the scaling decision
+        let pb_clone = pb.clone();
+        tokio::spawn(async move {
+            let _ = pb_clone.poll().await;
+        });
+
+        // Wait for the first poll to complete
+        tokio::time::sleep(Duration::from_millis(20)).await;
+
+        // Let the hot loop run for 100ms while we continue to attempt consuming
+        tokio::time::sleep(Duration::from_millis(100)).await;
+        let hot_loop_calls = call_count.load(Ordering::SeqCst);
+
+        // Without backoff, this was producing ~6300 polls in ~100ms on my machine.
+        // With exponential backoff, I'm getting exactly 10 (initial poller count).
+        assert!(
+            hot_loop_calls == 10,
+            "Expected proper backoff with == 10 polls in 100ms, but got {} polls.",
+            hot_loop_calls
+        );
+
+        Arc::try_unwrap(pb)
+            .unwrap_or_else(|_| panic!("Failed to unwrap Arc"))
+            .shutdown()
+            .await;
+    }
+
+    #[rstest]
+    #[case::graceful(true)]
+    #[case::legacy(false)]
+    #[tokio::test]
+    async fn inflight_poll_survives_shutdown_only_when_graceful(#[case] graceful: bool) {
+        let mut mock_client = mock_manual_worker_client();
+        let task_started = Arc::new(Notify::new());
+        let task_started_clone = task_started.clone();
+        let task_complete = Arc::new(Notify::new());
+        let task_complete_clone = task_complete.clone();
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+
+        mock_client
+            .expect_poll_workflow_task()
+            .returning(move |_, _| {
+                let count = call_count_clone.fetch_add(1, Ordering::SeqCst);
+                let started = task_started_clone.clone();
+                let complete = task_complete_clone.clone();
+                async move {
+                    match count {
+                        0 => Ok(PollWorkflowTaskQueueResponse {
+                            task_token: vec![1],
+                            ..Default::default()
+                        }),
+                        _ => {
+                            started.notify_one();
+                            complete.notified().await;
+                            Ok(PollWorkflowTaskQueueResponse {
+                                task_token: vec![2],
+                                ..Default::default()
+                            })
+                        }
+                    }
+                }
+                .boxed()
+            });
+
+        let shutdown_token = CancellationToken::new();
+        let pb = LongPollBuffer::new_workflow_task(
+            Arc::new(mock_client),
+            "sometq".to_string(),
+            None,
+            PollerBehavior::SimpleMaximum(1),
+            fixed_size_permit_dealer(10),
+            shutdown_token.clone(),
+            None::<fn(usize)>,
+            WorkflowTaskOptions {
+                wft_poller_shared: None,
+            },
+            Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(graceful)),
+        );
+
+        let first = pb.poll().await.unwrap().unwrap();
+        assert_eq!(first.0.task_token, vec![1]);
+
+        // Wait for second poll to be in-flight
+        task_started.notified().await;
+
+        shutdown_token.cancel();
+
+        if graceful {
+            // Release the poll — simulates server returning empty after ShutdownWorker
+            task_complete.notify_one();
+
+            // Graceful: in-flight poll survives, second task is received
+            let second = tokio::time::timeout(Duration::from_secs(2), pb.poll())
+                .await
+                .expect("graceful poll should complete")
+                .unwrap()
+                .unwrap();
+            assert_eq!(second.0.task_token, vec![2]);
+        } else {
+            // Don't release — the poll should be killed by shutdown token before completing.
+            // Buffer drains to None because the killed poll sends no result.
+            let result = tokio::time::timeout(Duration::from_secs(2), pb.poll())
+                .await
+                .expect("legacy poll should resolve quickly");
+            assert!(
+                result.is_none(),
+                "Legacy shutdown should kill in-flight poll, buffer returns None"
+            );
+        }
+
+        pb.shutdown().await;
+    }
 }

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

@@ -1,10 +1,10 @@
 pub(crate) mod protocol_messages;
 
 use crate::{
-    CompleteActivityError, TaskToken,
+    TaskToken,
     protosext::protocol_messages::IncomingProtocolMessage,
     retry_logic::ValidatedRetryPolicy,
-    worker::{LEGACY_QUERY_ID, LocalActivityExecutionResult},
+    worker::{CompleteActivityError, LEGACY_QUERY_ID, LocalActivityExecutionResult},
 };
 use anyhow::anyhow;
 use itertools::Itertools;

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

@@ -3,9 +3,9 @@
 //! users during testing.
 
 use crate::{
-    Worker,
+    Worker, WorkerConfig,
     worker::{
-        PostActivateHookData,
+        PollerBehavior, PostActivateHookData,
         client::mocks::{MockManualWorkerClient, mock_manual_worker_client},
     },
 };
@@ -30,7 +30,7 @@ use temporalio_common::{
             },
         },
     },
-    worker::{PollerBehavior, WorkerConfig, WorkerTaskTypes},
+    worker::WorkerTaskTypes,
 };
 use tokio::sync::{Mutex as TokioMutex, mpsc, mpsc::UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -126,11 +126,20 @@ where
 
 /// A history which will be used during replay verification. Since histories do not include the
 /// workflow id, it must be manually attached.
-#[derive(Debug, Clone, derive_more::Constructor)]
+#[derive(Debug, Clone)]
 pub struct HistoryForReplay {
     hist: History,
     workflow_id: String,
 }
+impl HistoryForReplay {
+    /// Create a new history from replay from something that looks like a history and a workflow id.
+    pub fn new(history: impl Into<History>, workflow_id: impl Into<String>) -> Self {
+        Self {
+            hist: history.into(),
+            workflow_id: workflow_id.into(),
+        }
+    }
+}
 impl From<TestHistoryBuilder> for HistoryForReplay {
     fn from(thb: TestHistoryBuilder) -> Self {
         thb.get_full_history_info().unwrap().into()
@@ -138,7 +147,7 @@ impl From<TestHistoryBuilder> for HistoryForReplay {
 }
 impl From<HistoryInfo> for HistoryForReplay {
     fn from(histinfo: HistoryInfo) -> Self {
-        HistoryForReplay::new(histinfo.into(), "fake".to_owned())
+        HistoryForReplay::new(histinfo, "fake".to_owned())
     }
 }