@temporalio/core-bridge 0.16.4 → 0.18.0

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

@@ -0,0 +1,38 @@
+use std::fmt::{Debug, Display, Formatter};
+
+static LOCAL_ACT_TASK_TOKEN_PREFIX: &[u8] = b"local_act_";
+
+#[derive(Hash, Eq, PartialEq, Clone, derive_more::From, derive_more::Into)]
+/// Type-safe wrapper for task token bytes
+pub struct TaskToken(pub Vec<u8>);
+
+impl TaskToken {
+    /// Task tokens for local activities are always prefixed with a special sigil so they can
+    /// be identified easily
+    pub fn new_local_activity_token(unique_data: impl IntoIterator<Item = u8>) -> Self {
+        let mut bytes = LOCAL_ACT_TASK_TOKEN_PREFIX.to_vec();
+        bytes.extend(unique_data);
+        TaskToken(bytes)
+    }
+
+    /// Returns true if the task token is for a local activity
+    pub fn is_local_activity_task(&self) -> bool {
+        self.0.starts_with(LOCAL_ACT_TASK_TOKEN_PREFIX)
+    }
+}
+
+impl Display for TaskToken {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&fmt_tt(&self.0))
+    }
+}
+
+impl Debug for TaskToken {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!("TaskToken({})", fmt_tt(&self.0)))
+    }
+}
+
+pub fn fmt_tt(tt: &[u8]) -> String {
+    base64::encode(tt)
+}

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

@@ -0,0 +1,14 @@
+pub trait TryIntoOrNone<F, T> {
+    /// Turn an option of something into an option of another thing, trying to convert along the way
+    /// and returning `None` if that conversion fails
+    fn try_into_or_none(self) -> Option<T>;
+}
+
+impl<F, T> TryIntoOrNone<F, T> for Option<F>
+where
+    F: TryInto<T>,
+{
+    fn try_into_or_none(self) -> Option<T> {
+        self.map(TryInto::try_into).transpose().ok().flatten()
+    }
+}

package/sdk-core/test-utils/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "temporal-sdk-core-test-utils"
+version = "0.1.0"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+edition = "2021"
+
+[[bin]]
+name = "histfetch"
+path = "src/histfetch.rs"
+
+[dependencies]
+anyhow = "1.0"
+async-trait = "0.1"
+base64 = "0.13"
+futures = "0.3"
+log = "0.4"
+prost = "0.9"
+prost-types = "0.9"
+rand = "0.8"
+serde_json = "1.0"
+temporal-client = { path = "../client", features = ["mocks"] }
+temporal-sdk = { path = "../sdk" }
+temporal-sdk-core = { path = "../core" }
+temporal-sdk-core-api = { path = "../core-api" }
+thiserror = "1.0"
+tokio = "1.1"
+url = "2.2"
+uuid = "0.8"
+
+[dependencies.temporal-sdk-core-protos]
+path = "../sdk-core-protos"
+version = "0.1"

package/sdk-core/{src/test_help → test-utils/src}/canned_histories.rs

@@ -1,4 +1,4 @@
-use crate::test_help::TestHistoryBuilder;
+use temporal_sdk_core::replay::TestHistoryBuilder;
 use temporal_sdk_core_protos::{
     coresdk::common::NamespacedWorkflowExecution,
     temporal::api::{
@@ -22,13 +22,7 @@ pub fn single_timer(timer_id: &str) -> TestHistoryBuilder {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: timer_id.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, timer_id.to_string());
     t.add_workflow_task_scheduled_and_started();
     t
 }
@@ -58,13 +52,7 @@ pub fn cancel_timer(wait_timer_id: &str, cancel_timer_id: &str) -> TestHistoryBu
     t.add_full_wf_task();
     let cancel_timer_started_id = t.add_get_event_id(EventType::TimerStarted, None);
     let wait_timer_started_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: wait_timer_started_id,
-            timer_id: wait_timer_id.to_string(),
-        }),
-    );
+    t.add_timer_fired(wait_timer_started_id, wait_timer_id.to_string());
     // 8
     t.add_full_wf_task();
     // 11
@@ -97,20 +85,8 @@ pub fn parallel_timer(timer1: &str, timer2: &str) -> TestHistoryBuilder {
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
     let timer_2_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: timer1.to_string(),
-        }),
-    );
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_2_started_event_id,
-            timer_id: timer2.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, timer1.to_string());
+    t.add_timer_fired(timer_2_started_event_id, timer2.to_string());
     t.add_workflow_task_scheduled_and_started();
     t
 }
@@ -195,13 +171,7 @@ pub fn workflow_fails_with_failure_two_different_points(
     );
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: timer_2.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, timer_2.to_string());
     t.add_workflow_task_scheduled_and_started();
     t.add_workflow_task_failed_with_failure(
         WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure,
@@ -877,13 +847,7 @@ pub fn long_sequential_timers(num_tasks: usize) -> TestHistoryBuilder {
 
     for i in 1..=num_tasks {
         let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-        t.add(
-            EventType::TimerFired,
-            history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                started_event_id: timer_started_event_id,
-                timer_id: i.to_string(),
-            }),
-        );
+        t.add_timer_fired(timer_started_event_id, i.to_string());
         t.add_full_wf_task();
     }
 
@@ -922,13 +886,7 @@ pub fn unsent_at_cancel_repro() -> TestHistoryBuilder {
         ),
     );
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: 1.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, 1.to_string());
 
     t.add_full_wf_task();
     t.add_activity_task_cancel_requested(scheduled_event_id);
@@ -1098,13 +1056,7 @@ pub fn timer_then_continue_as_new(timer_id: &str) -> TestHistoryBuilder {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: timer_id.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, timer_id.to_string());
     t.add_full_wf_task();
     t.add_continued_as_new();
     t
@@ -1153,13 +1105,7 @@ pub fn timer_wf_cancel_req_failed(timer_id: &str) -> TestHistoryBuilder {
 pub fn timer_wf_cancel_req_do_another_timer_then_cancelled() -> TestHistoryBuilder {
     timer_cancel_req_then("1", |t| {
         let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-        t.add(
-            EventType::TimerFired,
-            history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-                started_event_id: timer_started_event_id,
-                timer_id: "2".to_string(),
-            }),
-        );
+        t.add_timer_fired(timer_started_event_id, "2".to_string());
         t.add_full_wf_task();
         t.add_cancelled();
     })
@@ -1184,13 +1130,7 @@ fn timer_cancel_req_then(
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
     let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: timer_id.to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, timer_id.to_string());
     t.add_cancel_requested();
     t.add_full_wf_task();
     end_action(&mut t);
@@ -1277,13 +1217,7 @@ pub fn activity_double_resolve_repro() -> TestHistoryBuilder {
     t.add_we_signaled("sig2", vec![]);
     t.add_workflow_task_started();
     t.add_workflow_task_timed_out();
-    t.add(
-        EventType::TimerFired,
-        history_event::Attributes::TimerFiredEventAttributes(TimerFiredEventAttributes {
-            started_event_id: timer_started_event_id,
-            timer_id: "2".to_string(),
-        }),
-    );
+    t.add_timer_fired(timer_started_event_id, "2".to_string());
     t.add_full_wf_task();
     t.add_workflow_execution_completed();
 
@@ -1511,3 +1445,50 @@ pub fn single_child_workflow_start_fail(child_wf_id: &str) -> TestHistoryBuilder
     t.add_workflow_execution_completed();
     t
 }
+
+///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
+///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+///  5: EVENT_TYPE_MARKER_RECORDED (la result)
+///  7: EVENT_TYPE_MARKER_RECORDED (la result)
+///  8: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
+pub fn two_local_activities_one_wft(parallel: bool) -> TestHistoryBuilder {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    let mut start_time = t.wft_start_time();
+    start_time.seconds += 1;
+    t.add_local_activity_result_marker_with_time(1, "1", b"hi".into(), start_time.clone());
+    if !parallel {
+        start_time.seconds += 1;
+    }
+    t.add_local_activity_result_marker_with_time(2, "2", b"hi2".into(), start_time);
+    t.add_workflow_execution_completed();
+    t
+}
+
+///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
+///  2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  3: EVENT_TYPE_WORKFLOW_TASK_STARTED
+///  4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+///  5: EVENT_TYPE_MARKER_RECORDED (la result)
+///  6: EVENT_TYPE_TIMER_STARTED
+///  7: EVENT_TYPE_TIMER_FIRED
+///  8: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
+///  9: EVENT_TYPE_WORKFLOW_TASK_STARTED
+/// 10: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
+/// 11: EVENT_TYPE_MARKER_RECORDED (la result)
+/// 12: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
+pub fn two_local_activities_separated_by_timer() -> TestHistoryBuilder {
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_local_activity_result_marker(1, "1", b"hi".into());
+    let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
+    t.add_timer_fired(timer_started_event_id, "1".to_string());
+    t.add_full_wf_task();
+    t.add_local_activity_result_marker(2, "2", b"hi2".into());
+    t.add_workflow_execution_completed();
+    t
+}

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

@@ -0,0 +1,28 @@
+//! Use this binary to fetch histories as proto-encoded binary. The first argument must be a
+//! workflow ID. A run id may optionally be provided as the second arg. The history is written to
+//! `{workflow_id}_history.bin`.
+//!
+//! We can use `clap` if this needs more arguments / other stuff later on.
+
+use prost::Message;
+use temporal_client::ServerGatewayApis;
+use temporal_sdk_core_test_utils::get_integ_server_options;
+
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
+    let gw_opts = get_integ_server_options();
+    let gateway = gw_opts.connect(None).await?;
+    let wf_id = std::env::args()
+        .nth(1)
+        .expect("must provide workflow id as only argument");
+    let run_id = std::env::args().nth(2);
+    let hist = gateway
+        .get_workflow_execution_history(wf_id.clone(), run_id, vec![])
+        .await?
+        .history
+        .expect("history field must be populated");
+    // Serialize history to file
+    let byteified = hist.encode_to_vec();
+    tokio::fs::write(format!("{}_history.bin", wf_id), &byteified).await?;
+    Ok(())
+}

package/sdk-core/{test_utils → test-utils}/src/lib.rs

@@ -1,31 +1,78 @@
+//! This crate contains testing functionality that can be useful when building SDKs against Core,
+//! or even when testing workflows written in SDKs that use Core.
+
+pub mod canned_histories;
+
 use futures::{stream::FuturesUnordered, StreamExt};
 use log::LevelFilter;
+use prost::Message;
 use rand::{distributions::Standard, Rng};
-use std::{convert::TryFrom, env, future::Future, net::SocketAddr, sync::Arc, time::Duration};
+use std::{
+    convert::TryFrom, env, future::Future, net::SocketAddr, path::PathBuf, sync::Arc,
+    time::Duration,
+};
+use temporal_sdk::TestRustWorker;
 use temporal_sdk_core::{
-    prototype_rust_sdk::TestRustWorker, Core, CoreInitOptions, CoreInitOptionsBuilder,
-    ServerGatewayApis, ServerGatewayOptions, ServerGatewayOptionsBuilder, TelemetryOptions,
-    TelemetryOptionsBuilder, WorkerConfig, WorkerConfigBuilder,
+    replay::{init_core_replay, ReplayCore},
+    CoreInitOptions, CoreInitOptionsBuilder, ServerGatewayOptions, ServerGatewayOptionsBuilder,
+    TelemetryOptions, TelemetryOptionsBuilder, WorkerConfig, WorkerConfigBuilder,
 };
-use temporal_sdk_core_protos::coresdk::{
-    workflow_commands::{
-        workflow_command, ActivityCancellationType, CompleteWorkflowExecution, ScheduleActivity,
-        StartTimer,
+use temporal_sdk_core_api::Core;
+use temporal_sdk_core_protos::{
+    coresdk::{
+        workflow_commands::{
+            workflow_command, ActivityCancellationType, CompleteWorkflowExecution,
+            ScheduleActivity, StartTimer,
+        },
+        workflow_completion::WorkflowActivationCompletion,
     },
-    workflow_completion::WfActivationCompletion,
+    temporal::api::history::v1::History,
 };
 use url::Url;
 
 pub const NAMESPACE: &str = "default";
-pub type GwApi = Arc<dyn ServerGatewayApis>;
+pub const TEST_Q: &str = "q";
 /// 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";
 /// If set, enable direct scraping of prom metrics on the specified port
 const PROM_ENABLE_ENV_VAR: &str = "TEMPORAL_INTEG_PROM_PORT";
 
+/// Create a core instance which will use the provided test name to base the task queue and wf id
+/// upon. Returns the instance and the task queue name (which is also the workflow id).
+pub async fn init_core_and_create_wf(test_name: &str) -> (Arc<dyn Core>, String) {
+    let mut starter = CoreWfStarter::new(test_name);
+    let core = starter.get_core().await;
+    starter.start_wf().await;
+    (core, starter.get_task_queue().to_string())
+}
+
+/// Create a core replay instance preloaded with just one provided history. Returns the core impl
+/// and the task queue name as in [init_core_and_create_wf].
+pub fn init_core_replay_preloaded(test_name: &str, history: &History) -> (Arc<dyn Core>, String) {
+    let replay_core = init_core_replay(get_integ_telem_options());
+    let worker_cfg = WorkerConfigBuilder::default()
+        .task_queue(test_name)
+        .build()
+        .expect("Configuration options construct properly");
+    replay_core
+        .make_replay_worker(worker_cfg, history)
+        .expect("Worker registration works");
+    (Arc::new(replay_core), test_name.to_string())
+}
+
+/// Load history from a file containing the protobuf serialization of it
+pub async fn history_from_proto_binary(path_from_root: &str) -> Result<History, anyhow::Error> {
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("..");
+    path.push(path_from_root);
+    let bytes = tokio::fs::read(path).await?;
+    Ok(History::decode(&*bytes)?)
+}
+
 /// Implements a builder pattern to help integ tests initialize core and create workflows
 pub struct CoreWfStarter {
-    test_name: String,
+    /// Used for both the task queue and workflow id
+    task_queue_name: String,
     core_options: CoreInitOptions,
     worker_config: WorkerConfig,
     wft_timeout: Option<Duration>,
@@ -37,8 +84,12 @@ impl CoreWfStarter {
         let rand_bytes: Vec<u8> = rand::thread_rng().sample_iter(&Standard).take(6).collect();
         let task_q_salt = base64::encode(rand_bytes);
         let task_queue = format!("{}_{}", test_name, task_q_salt);
+        Self::new_tq_name(&task_queue)
+    }
+
+    pub fn new_tq_name(task_queue: &str) -> Self {
         Self {
-            test_name: test_name.to_owned(),
+            task_queue_name: task_queue.to_owned(),
             core_options: CoreInitOptionsBuilder::default()
                 .gateway_opts(get_integ_server_options())
                 .telemetry_opts(get_integ_telem_options())
@@ -67,37 +118,65 @@ impl CoreWfStarter {
     }
 
     pub async fn get_core(&mut self) -> Arc<dyn Core> {
-        self.get_or_init_core().await
+        if self.initted_core.is_none() {
+            let core = temporal_sdk_core::init(self.core_options.clone())
+                .await
+                .unwrap();
+            // Register a worker for the task queue
+            core.register_worker(self.worker_config.clone()).unwrap();
+            self.initted_core = Some(Arc::new(core));
+        }
+        self.initted_core.as_ref().unwrap().clone()
     }
 
     /// Start the workflow defined by the builder and return run id
     pub async fn start_wf(&self) -> String {
-        self.start_wf_with_id(self.test_name.clone()).await
+        self.start_wf_with_id(self.task_queue_name.clone()).await
     }
 
     pub async fn start_wf_with_id(&self, workflow_id: String) -> String {
-        with_gw(
-            self.initted_core
-                .as_ref()
-                .expect(
-                    "Core must be initted before starting a workflow.\
+        self.initted_core
+            .as_ref()
+            .expect(
+                "Core must be initted before starting a workflow.\
                              Tests must call `get_core` first.",
-                )
-                .as_ref(),
-            |gw: GwApi| async move {
-                gw.start_workflow(
-                    vec![],
-                    self.worker_config.task_queue.clone(),
-                    workflow_id,
-                    self.test_name.clone(),
-                    self.wft_timeout,
-                )
-                .await
-                .unwrap()
-                .run_id
-            },
-        )
-        .await
+            )
+            .as_ref()
+            .server_gateway()
+            .start_workflow(
+                vec![],
+                self.worker_config.task_queue.clone(),
+                workflow_id,
+                self.task_queue_name.clone(),
+                self.wft_timeout,
+            )
+            .await
+            .unwrap()
+            .run_id
+    }
+
+    /// Fetch the history for the indicated workflow and replay it using the provided worker.
+    /// Can be used after completing workflows normally to ensure replay works as well.
+    pub async fn fetch_history_and_replay(
+        &mut self,
+        wf_id: impl Into<String>,
+        run_id: impl Into<String>,
+        worker: &mut TestRustWorker,
+    ) -> Result<(), anyhow::Error> {
+        // Fetch history and replay it
+        let history = self
+            .get_core()
+            .await
+            .server_gateway()
+            .get_workflow_execution_history(wf_id.into(), Some(run_id.into()), vec![])
+            .await?
+            .history
+            .expect("history field must be populated");
+        let (replay_core, _) = init_core_replay_preloaded(worker.task_queue(), &history);
+        let mut replay_worker = worker.swap_core(replay_core);
+        replay_worker.incr_expected_run_count(1);
+        replay_worker.run_until_done().await.unwrap();
+        Ok(())
     }
 
     pub fn get_task_queue(&self) -> &str {
@@ -105,7 +184,7 @@ impl CoreWfStarter {
     }
 
     pub fn get_wf_id(&self) -> &str {
-        &self.test_name
+        &self.task_queue_name
     }
 
     pub fn max_cached_workflows(&mut self, num: usize) -> &mut Self {
@@ -123,6 +202,11 @@ impl CoreWfStarter {
         self
     }
 
+    pub fn max_local_at(&mut self, max: usize) -> &mut Self {
+        self.worker_config.max_outstanding_local_activities = max;
+        self
+    }
+
     pub fn max_at_polls(&mut self, max: usize) -> &mut Self {
         self.worker_config.max_concurrent_at_polls = max;
         self
@@ -132,35 +216,6 @@ impl CoreWfStarter {
         self.wft_timeout = Some(timeout);
         self
     }
-
-    async fn get_or_init_core(&mut self) -> Arc<dyn Core> {
-        let opts = self.core_options.clone();
-        if self.initted_core.is_none() {
-            let core = temporal_sdk_core::init(opts).await.unwrap();
-            // Register a worker for the task queue
-            core.register_worker(self.worker_config.clone())
-                .await
-                .unwrap();
-            self.initted_core = Some(Arc::new(core));
-        }
-        self.initted_core.as_ref().unwrap().clone()
-    }
-}
-
-pub async fn init_core_and_create_wf(test_name: &str) -> (Arc<dyn Core>, String) {
-    let mut starter = CoreWfStarter::new(test_name);
-    let core = starter.get_core().await;
-    starter.start_wf().await;
-    (core, starter.get_task_queue().to_string())
-}
-
-// TODO: This should get removed. Pretty pointless now that gateway is exported
-pub async fn with_gw<F: FnOnce(GwApi) -> Fout, Fout: Future>(
-    core: &dyn Core,
-    fun: F,
-) -> Fout::Output {
-    let gw = core.server_gateway();
-    fun(gw).await
 }
 
 pub fn get_integ_server_options() -> ServerGatewayOptions {
@@ -194,7 +249,7 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
     {
         ob.prometheus_export_bind_address(addr);
     }
-    ob.tracing_filter("temporal_sdk_core=INFO".to_string())
+    ob.tracing_filter(env::var("RUST_LOG").unwrap_or_else(|_| "temporal_sdk_core=INFO".to_string()))
         .log_forwarding_level(LevelFilter::Off)
         .build()
         .unwrap()
@@ -224,6 +279,14 @@ pub fn schedule_activity_cmd(
     .into()
 }
 
+pub fn start_timer_cmd(seq: u32, duration: Duration) -> workflow_command::Variant {
+    StartTimer {
+        seq,
+        start_to_fire_timeout: Some(duration.into()),
+    }
+    .into()
+}
+
 /// Given a desired number of concurrent executions and a provided function that produces a future,
 /// run that many instances of the future concurrently.
 ///
@@ -256,7 +319,7 @@ where
     T: Core + ?Sized,
 {
     async fn complete_execution(&self, task_q: &str, run_id: &str) {
-        self.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        self.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             task_q.to_string(),
             run_id.to_string(),
             vec![CompleteWorkflowExecution { result: None }.into()],
@@ -266,7 +329,7 @@ where
     }
 
     async fn complete_timer(&self, task_q: &str, run_id: &str, seq: u32, duration: Duration) {
-        self.complete_workflow_activation(WfActivationCompletion::from_cmds(
+        self.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
             task_q.to_string(),
             run_id.to_string(),
             vec![StartTimer {

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

@@ -1,5 +1,5 @@
 use std::time::Duration;
-use test_utils::CoreWfStarter;
+use temporal_sdk_core_test_utils::CoreWfStarter;
 
 #[tokio::test]
 async fn can_use_retry_gateway() {

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

@@ -1,14 +1,18 @@
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_sdk_core_protos::coresdk::{
-    activity_result::{self, activity_result as act_res, ActivityResult},
+    activity_result::{
+        self, activity_resolution as act_res, ActivityExecutionResult, ActivityResolution,
+    },
     activity_task::activity_task as act_task,
     common::Payload,
-    workflow_activation::{wf_activation_job, ResolveActivity, WfActivationJob},
+    workflow_activation::{workflow_activation_job, ResolveActivity, WorkflowActivationJob},
     workflow_commands::ActivityCancellationType,
     ActivityHeartbeat, ActivityTaskCompletion, IntoCompletion,
 };
-use test_utils::{init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers};
+use temporal_sdk_core_test_utils::{
+    init_core_and_create_wf, schedule_activity_cmd, CoreTestHelpers,
+};
 use tokio::time::sleep;
 
 #[tokio::test]
@@ -58,7 +62,7 @@ async fn activity_heartbeat() {
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: task.task_token,
         task_queue: task_q.to_string(),
-        result: Some(ActivityResult::ok(response_payload.clone())),
+        result: Some(ActivityExecutionResult::ok(response_payload.clone())),
     })
     .await
     .unwrap();
@@ -67,9 +71,9 @@ async fn activity_heartbeat() {
     assert_matches!(
         task.jobs.as_slice(),
         [
-            WfActivationJob {
-                variant: Some(wf_activation_job::Variant::ResolveActivity(
-                    ResolveActivity {seq, result: Some(ActivityResult{
+            WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::ResolveActivity(
+                    ResolveActivity {seq, result: Some(ActivityResolution {
                     status: Some(act_res::Status::Completed(activity_result::Success{result: Some(r)})),
                      ..})}
                 )),