@temporalio/core-bridge 0.19.2 → 0.20.2

package/sdk-core/client/src/retry.rs

@@ -1,4 +1,7 @@
-use crate::{Result, RetryConfig, ServerGatewayApis, ServerGatewayOptions, WorkflowTaskCompletion};
+use crate::{
+    ClientOptions, Result, RetryConfig, WorkflowClientTrait, WorkflowOptions,
+    WorkflowTaskCompletion,
+};
 use backoff::{backoff::Backoff, ExponentialBackoff};
 use futures_retry::{ErrorHandler, FutureRetry, RetryPolicy};
 use std::{fmt::Debug, future::Future, time::Duration};
@@ -23,49 +26,88 @@ pub const RETRYABLE_ERROR_CODES: [Code; 7] = [
     Code::Unavailable,
 ];
 
-#[derive(Debug)]
-/// A wrapper for a [ServerGatewayApis] implementor which performs auto-retries
-pub struct RetryGateway<SG> {
-    gateway: SG,
+/// A wrapper for a [WorkflowClientTrait] or [crate::WorkflowService] implementor which performs
+/// auto-retries
+#[derive(Debug, Clone)]
+pub struct RetryClient<SG> {
+    client: SG,
     retry_config: RetryConfig,
 }
 
-impl<SG> RetryGateway<SG> {
-    /// Use the provided retry config with the provided gateway
-    pub const fn new(gateway: SG, retry_config: RetryConfig) -> Self {
+impl<SG> RetryClient<SG> {
+    /// Use the provided retry config with the provided client
+    pub const fn new(client: SG, retry_config: RetryConfig) -> Self {
         Self {
-            gateway,
+            client,
             retry_config,
         }
     }
 }
 
-impl<SG: ServerGatewayApis + Send + Sync + 'static> RetryGateway<SG> {
-    async fn call_with_retry<R, F, Fut>(
+impl<SG> RetryClient<SG> {
+    /// Return the inner client type
+    pub fn get_client(&self) -> &SG {
+        &self.client
+    }
+
+    /// Return the inner client type mutably
+    pub fn get_client_mut(&mut self) -> &mut SG {
+        &mut self.client
+    }
+
+    /// Disable retry and return the inner client type
+    pub fn into_inner(self) -> SG {
+        self.client
+    }
+
+    /// Wraps a call to the underlying client with retry capability.
+    ///
+    /// This is the "old" path used by higher-level [WorkflowClientTrait] implementors
+    pub(crate) async fn call_with_retry<R, F, Fut>(
         &self,
         factory: F,
-        ct: CallType,
         call_name: &'static str,
     ) -> Result<R>
     where
         F: Fn() -> Fut + Unpin,
         Fut: Future<Output = Result<R>>,
     {
-        let rtc = match ct {
+        let rtc = self.get_retry_config(call_name);
+        let res = Self::make_future_retry(rtc, factory, call_name).await;
+        Ok(res.map_err(|(e, _attempt)| e)?.0)
+    }
+
+    pub(crate) fn get_retry_config(&self, call_name: &'static str) -> RetryConfig {
+        let call_type = Self::determine_call_type(call_name);
+        match call_type {
             CallType::Normal => self.retry_config.clone(),
             CallType::LongPoll => RetryConfig::poll_retry_policy(),
-        };
-        Ok(
-            FutureRetry::new(factory, TonicErrorHandler::new(rtc, ct, call_name))
-                .await
-                .map_err(|(e, _attempt)| e)?
-                .0,
-        )
+        }
+    }
+
+    pub(crate) fn make_future_retry<R, F, Fut>(
+        rtc: RetryConfig,
+        factory: F,
+        call_name: &'static str,
+    ) -> FutureRetry<F, TonicErrorHandler>
+    where
+        F: FnMut() -> Fut + Unpin,
+        Fut: Future<Output = Result<R>>,
+    {
+        let call_type = Self::determine_call_type(call_name);
+        FutureRetry::new(factory, TonicErrorHandler::new(rtc, call_type, call_name))
+    }
+
+    fn determine_call_type(call_name: &str) -> CallType {
+        match call_name {
+            "poll_workflow_task" | "poll_activity_task" => CallType::LongPoll,
+            _ => CallType::Normal,
+        }
     }
 }
 
 #[derive(Debug)]
-struct TonicErrorHandler {
+pub(crate) struct TonicErrorHandler {
     backoff: ExponentialBackoff,
     max_retries: usize,
     call_type: CallType,
@@ -93,8 +135,9 @@ impl TonicErrorHandler {
         false
     }
 }
-#[derive(Debug, Eq, PartialEq, Hash)]
-enum CallType {
+#[doc(hidden)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub enum CallType {
     Normal,
     LongPoll,
 }
@@ -139,31 +182,39 @@ impl ErrorHandler<tonic::Status> for TonicErrorHandler {
 }
 
 macro_rules! retry_call {
-    ($myself:ident, $ctype:expr, $call_name:ident, $($args:expr),*) => {{
-        let fact = move || { $myself.gateway.$call_name($($args,)*)};
-        $myself.call_with_retry(fact, $ctype, stringify!($call_name)).await
-    }};
+    ($myself:ident, $call_name:ident) => { retry_call!($myself, $call_name,) };
+    ($myself:ident, $call_name:ident, $($args:expr),*) => {{
+        let call_name_str = stringify!($call_name);
+        let fact = || { $myself.get_client().$call_name($($args,)*)};
+        $myself.call_with_retry(fact, call_name_str).await
+    }}
 }
 
+// Ideally, this would be auto-implemented for anything that implements the raw client, but that
+// breaks all our retry clients which use a mock since it's based on this trait currently. Ideally
+// we would create an automock for the WorkflowServiceClient copy-paste trait and use that, but
+// that's a huge pain. Maybe one day tonic will provide traits.
 #[async_trait::async_trait]
-impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryGateway<SG> {
+impl<SG> WorkflowClientTrait for RetryClient<SG>
+where
+    SG: WorkflowClientTrait + Send + Sync + 'static,
+{
     async fn start_workflow(
         &self,
         input: Vec<Payload>,
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
-        task_timeout: Option<Duration>,
+        options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             start_workflow,
             input.clone(),
             task_queue.clone(),
             workflow_id.clone(),
             workflow_type.clone(),
-            task_timeout
+            options.clone()
         )
     }
 
@@ -172,24 +223,19 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
         task_queue: String,
         is_sticky: bool,
     ) -> Result<PollWorkflowTaskQueueResponse> {
-        retry_call!(
-            self,
-            CallType::LongPoll,
-            poll_workflow_task,
-            task_queue.clone(),
-            is_sticky
-        )
+        retry_call!(self, poll_workflow_task, task_queue.clone(), is_sticky)
     }
 
     async fn poll_activity_task(
         &self,
         task_queue: String,
+        max_tasks_per_sec: Option<f64>,
     ) -> Result<PollActivityTaskQueueResponse> {
         retry_call!(
             self,
-            CallType::LongPoll,
             poll_activity_task,
-            task_queue.clone()
+            task_queue.clone(),
+            max_tasks_per_sec
         )
     }
 
@@ -200,7 +246,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<ResetStickyTaskQueueResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             reset_sticky_task_queue,
             workflow_id.clone(),
             run_id.clone()
@@ -211,12 +256,7 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
         &self,
         request: WorkflowTaskCompletion,
     ) -> Result<RespondWorkflowTaskCompletedResponse> {
-        retry_call!(
-            self,
-            CallType::Normal,
-            complete_workflow_task,
-            request.clone()
-        )
+        retry_call!(self, complete_workflow_task, request.clone())
     }
 
     async fn complete_activity_task(
@@ -226,7 +266,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RespondActivityTaskCompletedResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             complete_activity_task,
             task_token.clone(),
             result.clone()
@@ -240,7 +279,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             record_activity_heartbeat,
             task_token.clone(),
             details.clone()
@@ -254,7 +292,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RespondActivityTaskCanceledResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             cancel_activity_task,
             task_token.clone(),
             details.clone()
@@ -268,7 +305,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RespondActivityTaskFailedResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             fail_activity_task,
             task_token.clone(),
             failure.clone()
@@ -283,7 +319,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RespondWorkflowTaskFailedResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             fail_workflow_task,
             task_token.clone(),
             cause,
@@ -300,7 +335,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<SignalWorkflowExecutionResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             signal_workflow_execution,
             workflow_id.clone(),
             run_id.clone(),
@@ -317,7 +351,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<QueryWorkflowResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             query_workflow_execution,
             workflow_id.clone(),
             run_id.clone(),
@@ -332,7 +365,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<DescribeWorkflowExecutionResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             describe_workflow_execution,
             workflow_id.clone(),
             run_id.clone()
@@ -347,7 +379,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             get_workflow_execution_history,
             workflow_id.clone(),
             run_id.clone(),
@@ -362,7 +393,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RespondQueryTaskCompletedResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             respond_legacy_query,
             task_token.clone(),
             query_result.clone()
@@ -376,7 +406,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<RequestCancelWorkflowExecutionResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             cancel_workflow_execution,
             workflow_id.clone(),
             run_id.clone()
@@ -390,7 +419,6 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     ) -> Result<TerminateWorkflowExecutionResponse> {
         retry_call!(
             self,
-            CallType::Normal,
             terminate_workflow_execution,
             workflow_id.clone(),
             run_id.clone()
@@ -398,18 +426,22 @@ impl<SG: ServerGatewayApis + Send + Sync + 'static> ServerGatewayApis for RetryG
     }
 
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse> {
-        retry_call!(self, CallType::Normal, list_namespaces,)
+        retry_call!(self, list_namespaces,)
     }
 
-    fn get_options(&self) -> &ServerGatewayOptions {
-        self.gateway.get_options()
+    fn get_options(&self) -> &ClientOptions {
+        self.client.get_options()
+    }
+
+    fn namespace(&self) -> &str {
+        self.client.namespace()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::MockServerGatewayApis;
+    use crate::MockWorkflowClientTrait;
     use tonic::Status;
 
     #[tokio::test]
@@ -425,13 +457,13 @@ mod tests {
             Code::Unauthenticated,
             Code::Unimplemented,
         ] {
-            let mut mock_gateway = MockServerGatewayApis::new();
-            mock_gateway
+            let mut mock_client = MockWorkflowClientTrait::new();
+            mock_client
                 .expect_cancel_activity_task()
                 .returning(move |_, _| Err(Status::new(code, "non-retryable failure")))
                 .times(1);
-            let retry_gateway = RetryGateway::new(mock_gateway, Default::default());
-            let result = retry_gateway
+            let retry_client = RetryClient::new(mock_client, Default::default());
+            let result = retry_client
                 .cancel_activity_task(vec![1].into(), None)
                 .await;
             // Expecting an error after a single attempt, since there was a non-retryable error.
@@ -450,21 +482,23 @@ mod tests {
             Code::Unauthenticated,
             Code::Unimplemented,
         ] {
-            let mut mock_gateway = MockServerGatewayApis::new();
-            mock_gateway
+            let mut mock_client = MockWorkflowClientTrait::new();
+            mock_client
                 .expect_poll_workflow_task()
                 .returning(move |_, _| Err(Status::new(code, "non-retryable failure")))
                 .times(1);
-            mock_gateway
+            mock_client
                 .expect_poll_activity_task()
-                .returning(move |_| Err(Status::new(code, "non-retryable failure")))
+                .returning(move |_, _| Err(Status::new(code, "non-retryable failure")))
                 .times(1);
-            let retry_gateway = RetryGateway::new(mock_gateway, Default::default());
-            let result = retry_gateway
+            let retry_client = RetryClient::new(mock_client, Default::default());
+            let result = retry_client
                 .poll_workflow_task("tq".to_string(), false)
                 .await;
             assert!(result.is_err());
-            let result = retry_gateway.poll_activity_task("tq".to_string()).await;
+            let result = retry_client
+                .poll_activity_task("tq".to_string(), None)
+                .await;
             assert!(result.is_err());
         }
     }
@@ -472,18 +506,18 @@ mod tests {
     #[tokio::test]
     async fn retryable_errors() {
         for code in RETRYABLE_ERROR_CODES {
-            let mut mock_gateway = MockServerGatewayApis::new();
-            mock_gateway
+            let mut mock_client = MockWorkflowClientTrait::new();
+            mock_client
                 .expect_cancel_activity_task()
                 .returning(move |_, _| Err(Status::new(code, "retryable failure")))
                 .times(3);
-            mock_gateway
+            mock_client
                 .expect_cancel_activity_task()
                 .returning(|_, _| Ok(Default::default()))
                 .times(1);
 
-            let retry_gateway = RetryGateway::new(mock_gateway, Default::default());
-            let result = retry_gateway
+            let retry_client = RetryClient::new(mock_client, Default::default());
+            let result = retry_client
                 .cancel_activity_task(vec![1].into(), None)
                 .await;
             // Expecting successful response after retries
@@ -493,31 +527,33 @@ mod tests {
 
     #[tokio::test]
     async fn long_poll_retries_forever() {
-        let mut mock_gateway = MockServerGatewayApis::new();
-        mock_gateway
+        let mut mock_client = MockWorkflowClientTrait::new();
+        mock_client
             .expect_poll_workflow_task()
             .returning(move |_, _| Err(Status::new(Code::Unknown, "retryable failure")))
             .times(50);
-        mock_gateway
+        mock_client
             .expect_poll_workflow_task()
             .returning(|_, _| Ok(Default::default()))
             .times(1);
-        mock_gateway
+        mock_client
             .expect_poll_activity_task()
-            .returning(move |_| Err(Status::new(Code::Unknown, "retryable failure")))
+            .returning(move |_, _| Err(Status::new(Code::Unknown, "retryable failure")))
             .times(50);
-        mock_gateway
+        mock_client
             .expect_poll_activity_task()
-            .returning(|_| Ok(Default::default()))
+            .returning(|_, _| Ok(Default::default()))
             .times(1);
 
-        let retry_gateway = RetryGateway::new(mock_gateway, Default::default());
+        let retry_client = RetryClient::new(mock_client, Default::default());
 
-        let result = retry_gateway
+        let result = retry_client
             .poll_workflow_task("tq".to_string(), false)
             .await;
         assert!(result.is_ok());
-        let result = retry_gateway.poll_activity_task("tq".to_string()).await;
+        let result = retry_client
+            .poll_activity_task("tq".to_string(), None)
+            .await;
         assert!(result.is_ok());
     }
 
@@ -525,31 +561,33 @@ mod tests {
     async fn long_poll_retries_deadline_exceeded() {
         // For some reason we will get cancelled in these situations occasionally (always?) too
         for code in [Code::Cancelled, Code::DeadlineExceeded] {
-            let mut mock_gateway = MockServerGatewayApis::new();
-            mock_gateway
+            let mut mock_client = MockWorkflowClientTrait::new();
+            mock_client
                 .expect_poll_workflow_task()
                 .returning(move |_, _| Err(Status::new(code, "retryable failure")))
                 .times(5);
-            mock_gateway
+            mock_client
                 .expect_poll_workflow_task()
                 .returning(|_, _| Ok(Default::default()))
                 .times(1);
-            mock_gateway
+            mock_client
                 .expect_poll_activity_task()
-                .returning(move |_| Err(Status::new(code, "retryable failure")))
+                .returning(move |_, _| Err(Status::new(code, "retryable failure")))
                 .times(5);
-            mock_gateway
+            mock_client
                 .expect_poll_activity_task()
-                .returning(|_| Ok(Default::default()))
+                .returning(|_, _| Ok(Default::default()))
                 .times(1);
 
-            let retry_gateway = RetryGateway::new(mock_gateway, Default::default());
+            let retry_client = RetryClient::new(mock_client, Default::default());
 
-            let result = retry_gateway
+            let result = retry_client
                 .poll_workflow_task("tq".to_string(), false)
                 .await;
             assert!(result.is_ok());
-            let result = retry_gateway.poll_activity_task("tq".to_string()).await;
+            let result = retry_client
+                .poll_activity_task("tq".to_string(), None)
+                .await;
             assert!(result.is_ok());
         }
     }

package/sdk-core/core/Cargo.toml

@@ -19,7 +19,7 @@ async-trait = "0.1"
 base64 = "0.13"
 crossbeam = "0.8"
 dashmap = "5.0"
-derive_builder = "0.10"
+derive_builder = "0.11"
 derive_more = "0.99"
 enum_dispatch = "0.3"
 futures = "0.3"
@@ -29,26 +29,28 @@ itertools = "0.10"
 lazy_static = "1.4"
 log = "0.4"
 lru = "0.7"
+mockall = "0.11"
 once_cell = "1.5"
-opentelemetry = { version = "0.16", features = ["rt-tokio"] }
-opentelemetry-otlp = { version = "0.9.0", features = ["tokio", "metrics"] }
-opentelemetry-prometheus = "0.9.0"
-parking_lot = { version = "0.11", features = ["send_guard"] }
-prometheus = "0.12"
+opentelemetry = { version = "0.17", features = ["rt-tokio"] }
+opentelemetry-otlp = { version = "0.10.0", features = ["tokio", "metrics"] }
+opentelemetry-prometheus = "0.10.0"
+parking_lot = { version = "0.12", features = ["send_guard"] }
+prometheus = "0.13"
 prost = "0.9"
 prost-types = "0.9"
 rand = "0.8.3"
 ringbuf = "0.2"
 serde = "1.0"
+siphasher = "0.3"
 slotmap = "1.0"
 thiserror = "1.0"
 tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
-tokio-util = { version = "0.6.9" }
+tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tonic = { version = "0.6", features = ["tls", "tls-roots"] }
 tracing = { version = "0.1", features = ["log-always"] }
 tracing-futures = "0.2"
-tracing-opentelemetry = "0.16"
+tracing-opentelemetry = "0.17"
 tracing-subscriber = { version = "0.3", features = ["parking_lot", "env-filter"] }
 url = "2.2"
 uuid = { version = "0.8.2", features = ["v4"] }
@@ -66,7 +68,6 @@ features = ["history_builders"]
 [dependencies.temporal-client]
 path = "../client"
 version = "0.1"
-features = ["mocks"]
 
 [dependencies.rustfsm]
 path = "../fsm"
@@ -75,7 +76,7 @@ version = "0.1"
 [dev-dependencies]
 assert_matches = "1.4"
 bimap = "0.6.1"
-mockall = "0.11"
+criterion = "0.3"
 rstest = "0.12"
 temporal-sdk-core-test-utils = { path = "../test-utils" }
 temporal-sdk = { path = "../sdk" }
@@ -94,3 +95,7 @@ test = false
 name = "load_tests"
 path = "../tests/load_tests.rs"
 test = false
+
+[[bench]]
+name = "workflow_replay"
+harness = false

package/sdk-core/core/LICENSE.txt

@@ -0,0 +1,23 @@
+Temporal Core SDK
+
+The MIT License
+
+Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/sdk-core/core/benches/workflow_replay.rs

@@ -0,0 +1,79 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use futures::StreamExt;
+use std::time::Duration;
+use temporal_sdk::{WfContext, Worker, WorkflowFunction};
+use temporal_sdk_core::{telemetry_init, TelemetryOptionsBuilder};
+use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
+use temporal_sdk_core_test_utils::{canned_histories, init_core_replay_preloaded};
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let tokio_runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap();
+    telemetry_init(
+        &TelemetryOptionsBuilder::default()
+            .totally_disable(true)
+            .build()
+            .unwrap(),
+    )
+    .unwrap();
+    let _g = tokio_runtime.enter();
+
+    let num_timers = 10;
+    let t = canned_histories::long_sequential_timers(num_timers as usize);
+    let hist = t.get_full_history_info().unwrap().into();
+
+    c.bench_function("Small history replay", |b| {
+        b.iter(|| {
+            tokio_runtime.block_on(async {
+                let func = timers_wf(num_timers);
+                let (worker, _) = init_core_replay_preloaded("replay_bench", &hist);
+                let mut worker = Worker::new_from_core(worker, "replay_bench".to_string());
+                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+                worker.run().await.unwrap();
+            })
+        })
+    });
+
+    let num_tasks = 50;
+    let t = canned_histories::lots_of_big_signals(num_tasks);
+    let hist = t.get_full_history_info().unwrap().into();
+
+    c.bench_function("Large payloads history replay", |b| {
+        b.iter(|| {
+            tokio_runtime.block_on(async {
+                let func = big_signals_wf(num_tasks);
+                let (worker, _) = init_core_replay_preloaded("large_hist_bench", &hist);
+                let mut worker = Worker::new_from_core(worker, "large_hist_bench".to_string());
+                worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
+                worker.run().await.unwrap();
+            })
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
+
+fn timers_wf(num_timers: u32) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        for _ in 1..=num_timers {
+            ctx.timer(Duration::from_secs(1)).await;
+        }
+        Ok(().into())
+    })
+}
+
+fn big_signals_wf(num_tasks: usize) -> WorkflowFunction {
+    WorkflowFunction::new(move |ctx: WfContext| async move {
+        let mut sigs = ctx.make_signal_channel("bigsig");
+        for _ in 1..=num_tasks {
+            for _ in 1..=5 {
+                let _ = sigs.next().await.unwrap();
+            }
+        }
+
+        Ok(().into())
+    })
+}