@temporalio/core-bridge 1.12.0 → 1.12.2

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

@@ -1,4 +1,4 @@
-use crate::{AttachMetricLabels, CallType};
+use crate::{AttachMetricLabels, CallType, dbg_panic};
 use futures_util::{FutureExt, future::BoxFuture};
 use std::{
     sync::Arc,
@@ -6,10 +6,10 @@ use std::{
     time::{Duration, Instant},
 };
 use temporal_sdk_core_api::telemetry::metrics::{
-    CoreMeter, Counter, HistogramDuration, MetricAttributes, MetricKeyValue, MetricParameters,
-    TemporalMeter,
+    CoreMeter, Counter, CounterBase, HistogramDuration, HistogramDurationBase, MetricAttributable,
+    MetricAttributes, MetricKeyValue, MetricParameters, TemporalMeter,
 };
-use tonic::{Code, body::BoxBody, transport::Channel};
+use tonic::{Code, body::Body, transport::Channel};
 use tower::Service;
 
 /// The string name (which may be prefixed) for this metric
@@ -26,22 +26,24 @@ pub(crate) struct MetricsContext {
     meter: Arc<dyn CoreMeter>,
     kvs: MetricAttributes,
     poll_is_long: bool,
+    instruments: Instruments,
+}
+#[derive(Clone)]
+struct Instruments {
+    svc_request: Counter,
+    svc_request_failed: Counter,
+    long_svc_request: Counter,
+    long_svc_request_failed: Counter,
 
-    svc_request: Arc<dyn Counter>,
-    svc_request_failed: Arc<dyn Counter>,
-    long_svc_request: Arc<dyn Counter>,
-    long_svc_request_failed: Arc<dyn Counter>,
-
-    svc_request_latency: Arc<dyn HistogramDuration>,
-    long_svc_request_latency: Arc<dyn HistogramDuration>,
+    svc_request_latency: HistogramDuration,
+    long_svc_request_latency: HistogramDuration,
 }
 
 impl MetricsContext {
     pub(crate) fn new(tm: TemporalMeter) -> Self {
         let meter = tm.inner;
-        Self {
-            kvs: meter.new_attributes(tm.default_attribs),
-            poll_is_long: false,
+        let kvs = meter.new_attributes(tm.default_attribs);
+        let instruments = Instruments {
             svc_request: meter.counter(MetricParameters {
                 name: "request".into(),
                 description: "Count of client request successes by rpc name".into(),
@@ -72,6 +74,11 @@ impl MetricsContext {
                 unit: "duration".into(),
                 description: "Histogram of client long-poll request latencies".into(),
             }),
+        };
+        Self {
+            kvs,
+            poll_is_long: false,
+            instruments,
             meter,
         }
     }
@@ -81,6 +88,33 @@ impl MetricsContext {
         self.kvs = self
             .meter
             .extend_attributes(self.kvs.clone(), new_kvs.into());
+
+        let _ = self
+            .instruments
+            .svc_request
+            .with_attributes(&self.kvs)
+            .and_then(|v| {
+                self.instruments.svc_request = v;
+                self.instruments.long_svc_request.with_attributes(&self.kvs)
+            })
+            .and_then(|v| {
+                self.instruments.long_svc_request = v;
+                self.instruments
+                    .svc_request_latency
+                    .with_attributes(&self.kvs)
+            })
+            .and_then(|v| {
+                self.instruments.svc_request_latency = v;
+                self.instruments
+                    .long_svc_request_latency
+                    .with_attributes(&self.kvs)
+            })
+            .map(|v| {
+                self.instruments.long_svc_request_latency = v;
+            })
+            .inspect_err(|e| {
+                dbg_panic!("Failed to extend client metrics attributes: {:?}", e);
+            });
     }
 
     pub(crate) fn set_is_long_poll(&mut self) {
@@ -90,9 +124,9 @@ impl MetricsContext {
     /// A request to the temporal service was made
     pub(crate) fn svc_request(&self) {
         if self.poll_is_long {
-            self.long_svc_request.add(1, &self.kvs);
+            self.instruments.long_svc_request.adds(1);
         } else {
-            self.svc_request.add(1, &self.kvs);
+            self.instruments.svc_request.adds(1);
         }
     }
 
@@ -108,18 +142,18 @@ impl MetricsContext {
             &self.kvs
         };
         if self.poll_is_long {
-            self.long_svc_request_failed.add(1, kvs);
+            self.instruments.long_svc_request_failed.add(1, kvs);
         } else {
-            self.svc_request_failed.add(1, kvs);
+            self.instruments.svc_request_failed.add(1, kvs);
         }
     }
 
     /// Record service request latency
     pub(crate) fn record_svc_req_latency(&self, dur: Duration) {
         if self.poll_is_long {
-            self.long_svc_request_latency.record(dur, &self.kvs);
+            self.instruments.long_svc_request_latency.records(dur);
         } else {
-            self.svc_request_latency.record(dur, &self.kvs);
+            self.instruments.svc_request_latency.records(dur);
         }
     }
 }
@@ -177,8 +211,8 @@ pub struct GrpcMetricSvc {
     pub(crate) disable_errcode_label: bool,
 }
 
-impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
-    type Response = http::Response<BoxBody>;
+impl Service<http::Request<Body>> for GrpcMetricSvc {
+    type Response = http::Response<Body>;
     type Error = tonic::transport::Error;
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -186,7 +220,7 @@ impl Service<http::Request<BoxBody>> for GrpcMetricSvc {
         self.inner.poll_ready(cx).map_err(Into::into)
     }
 
-    fn call(&mut self, mut req: http::Request<BoxBody>) -> Self::Future {
+    fn call(&mut self, mut req: http::Request<Body>) -> Self::Future {
         let metrics = self
             .metrics
             .clone()

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

@@ -24,7 +24,7 @@ use temporal_sdk_core_protos::{
 };
 use tonic::{
     Request, Response, Status,
-    body::BoxBody,
+    body::Body,
     client::GrpcService,
     metadata::{AsciiMetadataValue, KeyAndValueRef},
 };
@@ -166,7 +166,7 @@ where
 impl<T> RawClientLike for TemporalServiceClient<T>
 where
     T: Send + Sync + Clone + 'static,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
@@ -221,7 +221,7 @@ where
 impl<T> RawClientLike for ConfiguredClient<TemporalServiceClient<T>>
 where
     T: Send + Sync + Clone + 'static,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
@@ -373,7 +373,7 @@ pub(super) struct IsUserLongPoll;
 impl<RC, T> WorkflowService for RC
 where
     RC: RawClientLike<SvcType = T>,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
@@ -383,7 +383,7 @@ where
 impl<RC, T> OperatorService for RC
 where
     RC: RawClientLike<SvcType = T>,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
@@ -393,7 +393,7 @@ where
 impl<RC, T> CloudService for RC
 where
     RC: RawClientLike<SvcType = T>,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
@@ -403,7 +403,7 @@ where
 impl<RC, T> TestService for RC
 where
     RC: RawClientLike<SvcType = T>,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
@@ -413,7 +413,7 @@ where
 impl<RC, T> HealthService for RC
 where
     RC: RawClientLike<SvcType = T>,
-    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T: GrpcService<Body> + Send + Clone + 'static,
     T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
     T::Error: Into<tonic::codegen::StdError>,
     T::Future: Send,
@@ -437,7 +437,7 @@ macro_rules! proxy {
         fn $method(
             &mut self,
             request: impl tonic::IntoRequest<$req>,
-        ) -> BoxFuture<Result<tonic::Response<$resp>, tonic::Status>> {
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             #[allow(unused_mut)]
             let mut as_req = request.into_request();
             $( type_closure_arg(&mut as_req, $closure); )*
@@ -455,7 +455,7 @@ macro_rules! proxy {
         fn $method(
             &mut self,
             request: impl tonic::IntoRequest<$req>,
-        ) -> BoxFuture<Result<tonic::Response<$resp>, tonic::Status>> {
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             #[allow(unused_mut)]
             let mut as_req = request.into_request();
             type_closure_arg(&mut as_req, $closure_request);
@@ -483,13 +483,13 @@ macro_rules! proxier {
         pub trait $trait_name: RawClientLike
         where
             // Yo this is wild
-            <Self as RawClientLike>::SvcType: GrpcService<BoxBody> + Send + Clone + 'static,
-            <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::ResponseBody:
+            <Self as RawClientLike>::SvcType: GrpcService<Body> + Send + Clone + 'static,
+            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody:
                 tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-            <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::Error:
+            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Error:
                 Into<tonic::codegen::StdError>,
-            <<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::Future: Send,
-            <<<Self as RawClientLike>::SvcType as GrpcService<BoxBody>>::ResponseBody
+            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Future: Send,
+            <<<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody
                 as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
         {
             $(
@@ -1336,6 +1336,24 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        list_workers,
+        ListWorkersRequest,
+        ListWorkersResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        record_worker_heartbeat,
+        RecordWorkerHeartbeatRequest,
+        RecordWorkerHeartbeatResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
 }
 
 proxier! {

package/sdk-core/core/Cargo.toml

@@ -13,9 +13,10 @@ categories = ["development-tools"]
 [lib]
 
 [features]
-default = ["otel"]
-otel = ["dep:opentelemetry", "dep:opentelemetry_sdk", "dep:opentelemetry-otlp",
-    "dep:opentelemetry-prometheus", "dep:hyper", "dep:hyper-util", "dep:http-body-util"]
+default = ["otel", "prom"]
+otel = ["dep:opentelemetry", "dep:opentelemetry_sdk", "dep:opentelemetry-otlp", "dep:hyper",
+    "dep:hyper-util", "dep:http-body-util"]
+prom = ["dep:prometheus"]
 tokio-console = ["console-subscriber"]
 ephemeral-server = ["dep:flate2", "dep:reqwest", "dep:tar", "dep:zip"]
 debug-plugin = ["dep:reqwest"]
@@ -35,6 +36,7 @@ enum-iterator = "2"
 flate2 = { version = "1.0", optional = true }
 futures-util = { version = "0.3", default-features = false }
 futures-channel = { version = "0.3", default-features = false, features = ["std"] }
+gethostname = "1.0.2"
 governor = "0.8"
 http-body-util = { version = "0.1", optional = true }
 hyper = { version = "1.2", optional = true }
@@ -43,13 +45,12 @@ itertools = "0.14"
 lru = "0.13"
 mockall = "0.13"
 opentelemetry = { workspace = true, features = ["metrics"], optional = true }
-opentelemetry_sdk = { version = "0.29", features = ["rt-tokio", "metrics", "spec_unstable_metrics_views"], optional = true }
-opentelemetry-otlp = { version = "0.29", features = ["tokio", "metrics", "tls", "http-proto", "grpc-tonic"], optional = true }
-opentelemetry-prometheus = { version = "0.29", optional = true }
+opentelemetry_sdk = { version = "0.30", features = ["rt-tokio", "metrics", "spec_unstable_metrics_views"], optional = true }
+opentelemetry-otlp = { version = "0.30", features = ["tokio", "metrics", "tls", "http-proto", "grpc-tonic"], optional = true }
 parking_lot = { version = "0.12", features = ["send_guard"] }
 pid = "4.0"
 pin-project = "1.0"
-prometheus = "0.14"
+prometheus = { version = "0.14", optional = true }
 prost = { workspace = true }
 prost-types = { version = "0.6", package = "prost-wkt-types" }
 rand = "0.9"
@@ -65,7 +66,7 @@ thiserror = { workspace = true }
 tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process"] }
 tokio-util = { version = "0.7", features = ["io", "io-util"] }
 tokio-stream = "0.1"
-tonic = { workspace = true, features = ["tls", "tls-roots"] }
+tonic = { workspace = true, features = ["tls-ring", "tls-native-roots"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", default-features = false, features = ["parking_lot", "env-filter", "registry", "ansi"] }
 url = "2.2"
@@ -91,10 +92,11 @@ path = "../fsm"
 assert_matches = "1.4"
 bimap = "0.6.1"
 clap = { version = "4.0", features = ["derive"] }
-criterion = "0.5"
+criterion = { version = "0.6", features = ["async", "async_tokio"] }
 rstest = "0.25"
 temporal-sdk-core-test-utils = { path = "../test-utils" }
 temporal-sdk = { path = "../sdk" }
+tokio = { version = "1.37", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs", "process", "test-util"] }
 tokio-stream = { version = "0.1", features = ["net"] }
 
 [[test]]

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

@@ -1,10 +1,19 @@
-use criterion::{Criterion, criterion_group, criterion_main};
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use futures_util::StreamExt;
-use std::time::Duration;
+use std::{
+    sync::{Arc, mpsc},
+    thread,
+    time::Duration,
+};
 use temporal_sdk::{WfContext, WorkflowFunction};
-use temporal_sdk_core::replay::HistoryForReplay;
+use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay};
+use temporal_sdk_core_api::telemetry::metrics::{
+    MetricKeyValue, MetricParametersBuilder, NewAttributes,
+};
 use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
-use temporal_sdk_core_test_utils::{canned_histories, replay_sdk_worker};
+use temporal_sdk_core_test_utils::{
+    DONT_AUTO_INIT_INTEG_TELEM, canned_histories, prom_metrics, replay_sdk_worker,
+};
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     let tokio_runtime = tokio::runtime::Builder::new_current_thread()
@@ -12,6 +21,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         .build()
         .unwrap();
     let _g = tokio_runtime.enter();
+    DONT_AUTO_INIT_INTEG_TELEM.set(true);
 
     let num_timers = 10;
     let t = canned_histories::long_sequential_timers(num_timers as usize);
@@ -21,14 +31,17 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     );
 
     c.bench_function("Small history replay", |b| {
-        b.iter(|| {
-            tokio_runtime.block_on(async {
+        b.to_async(&tokio_runtime).iter_batched(
+            || {
                 let func = timers_wf(num_timers);
-                let mut worker = replay_sdk_worker([hist.clone()]);
+                (func, replay_sdk_worker([hist.clone()]))
+            },
+            |(func, mut worker)| async move {
                 worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
                 worker.run().await.unwrap();
-            })
-        })
+            },
+            BatchSize::SmallInput,
+        )
     });
 
     let num_tasks = 50;
@@ -39,18 +52,104 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     );
 
     c.bench_function("Large payloads history replay", |b| {
-        b.iter(|| {
-            tokio_runtime.block_on(async {
+        b.to_async(&tokio_runtime).iter_batched(
+            || {
                 let func = big_signals_wf(num_tasks);
-                let mut worker = replay_sdk_worker([hist.clone()]);
+                (func, replay_sdk_worker([hist.clone()]))
+            },
+            |(func, mut worker)| async move {
                 worker.register_wf(DEFAULT_WORKFLOW_TYPE, func);
                 worker.run().await.unwrap();
-            })
-        })
+            },
+            BatchSize::SmallInput,
+        )
     });
 }
 
-criterion_group!(benches, criterion_benchmark);
+pub fn bench_metrics(c: &mut Criterion) {
+    DONT_AUTO_INIT_INTEG_TELEM.set(true);
+    let tokio_runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    let _tokio = tokio_runtime.enter();
+    let (mut telemopts, addr, _aborter) = prom_metrics(None);
+    telemopts.logging = None;
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let meter = rt.telemetry().get_metric_meter().unwrap();
+
+    c.bench_function("Record with new attributes on each call", move |b| {
+        b.iter_batched(
+            || {
+                let c = meter.counter(
+                    MetricParametersBuilder::default()
+                        .name("c")
+                        .build()
+                        .unwrap(),
+                );
+                let h = meter.histogram(
+                    MetricParametersBuilder::default()
+                        .name("h")
+                        .build()
+                        .unwrap(),
+                );
+                let g = meter.gauge(
+                    MetricParametersBuilder::default()
+                        .name("g")
+                        .build()
+                        .unwrap(),
+                );
+
+                let vals = [1, 2, 3, 4, 5];
+                let labels = ["l1", "l2"];
+
+                let (start_tx, start_rx) = mpsc::channel();
+                let start_rx = Arc::new(std::sync::Mutex::new(start_rx));
+
+                let mut thread_handles = Vec::new();
+                for _ in 0..3 {
+                    let c = c.clone();
+                    let h = h.clone();
+                    let g = g.clone();
+                    let meter = meter.clone();
+                    let start_rx = start_rx.clone();
+
+                    let handle = thread::spawn(move || {
+                        // Wait for start signal
+                        let _ = start_rx.lock().unwrap().recv();
+
+                        for _ in 1..=100 {
+                            for &val in &vals {
+                                for &label in &labels {
+                                    let attribs = meter.new_attributes(NewAttributes::from(vec![
+                                        MetricKeyValue::new("label", label),
+                                    ]));
+                                    c.add(val, &attribs);
+                                    h.record(val, &attribs);
+                                    g.record(val, &attribs);
+                                }
+                            }
+                        }
+                    });
+                    thread_handles.push(handle);
+                }
+
+                (start_tx, thread_handles)
+            },
+            |(start_tx, thread_handles)| {
+                for _ in 0..3 {
+                    let _ = start_tx.send(());
+                }
+                for handle in thread_handles {
+                    let _ = handle.join();
+                }
+            },
+            BatchSize::SmallInput,
+        )
+    });
+}
+
+criterion_group!(benches, criterion_benchmark, bench_metrics);
 criterion_main!(benches);
 
 fn timers_wf(num_timers: u32) -> WorkflowFunction {

package/sdk-core/core/src/core_tests/activity_tasks.rs

@@ -6,7 +6,7 @@ use crate::{
         gen_assert_and_reply, mock_manual_poller, mock_poller, mock_poller_from_resps,
         mock_sdk_cfg, mock_worker, poll_and_reply, single_hist_mock_sg, test_worker_cfg,
     },
-    worker::client::mocks::{mock_manual_workflow_client, mock_workflow_client},
+    worker::client::mocks::{mock_manual_worker_client, mock_worker_client},
 };
 use futures_util::FutureExt;
 use itertools::Itertools;
@@ -86,7 +86,7 @@ fn three_tasks() -> VecDeque<PollActivityTaskQueueResponse> {
 async fn max_activities_respected() {
     let _task_q = "q";
     let mut tasks = three_tasks();
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_poll_activity_task()
         .times(3)
@@ -122,7 +122,7 @@ async fn max_activities_respected() {
 
 #[tokio::test]
 async fn activity_not_found_returns_ok() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     // Mock won't even be called, since we weren't tracking activity
     mock_client.expect_complete_activity_task().times(0);
 
@@ -139,7 +139,7 @@ async fn activity_not_found_returns_ok() {
 
 #[tokio::test]
 async fn heartbeats_report_cancels_only_once() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_record_activity_heartbeat()
         .times(2)
@@ -265,7 +265,7 @@ async fn activity_cancel_interrupts_poll() {
         .times(3)
         .returning(move || poll_resps.pop_front().unwrap());
 
-    let mut mock_client = mock_manual_workflow_client();
+    let mut mock_client = mock_manual_worker_client();
     mock_client
         .expect_record_activity_heartbeat()
         .times(1)
@@ -323,7 +323,7 @@ async fn activity_cancel_interrupts_poll() {
 
 #[tokio::test]
 async fn activity_poll_timeout_retries() {
-    let mock_client = mock_workflow_client();
+    let mock_client = mock_worker_client();
     let mut calls = 0;
     let mut mock_act_poller = mock_poller();
     mock_act_poller.expect_poll().times(3).returning(move || {
@@ -352,7 +352,7 @@ async fn many_concurrent_heartbeat_cancels() {
     // them after a few successful heartbeats
     const CONCURRENCY_NUM: usize = 5;
 
-    let mut mock_client = mock_manual_workflow_client();
+    let mut mock_client = mock_manual_worker_client();
     let mut poll_resps = VecDeque::from(
         (0..CONCURRENCY_NUM)
             .map(|i| {
@@ -516,7 +516,7 @@ async fn activity_timeout_no_double_resolve() {
 
 #[tokio::test]
 async fn can_heartbeat_acts_during_shutdown() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_record_activity_heartbeat()
         .times(1)
@@ -567,7 +567,7 @@ async fn can_heartbeat_acts_during_shutdown() {
 #[tokio::test]
 async fn complete_act_with_fail_flushes_heartbeat() {
     let last_hb = 50;
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     let last_seen_payload = Rc::new(RefCell::new(None));
     let lsp = last_seen_payload.clone();
     mock_client
@@ -622,7 +622,7 @@ async fn complete_act_with_fail_flushes_heartbeat() {
 #[tokio::test]
 async fn max_tq_acts_set_passed_to_poll_properly() {
     let rate = 9.28;
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_poll_activity_task()
         .returning(move |_, ao| {
@@ -659,7 +659,7 @@ async fn no_eager_activities_requested_when_worker_options_disable_it(
     let num_eager_requested = Arc::new(AtomicUsize::new(0));
     let num_eager_requested_clone = num_eager_requested.clone();
 
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_complete_workflow_task()
         .times(1)
         .returning(move |req| {
@@ -747,7 +747,7 @@ async fn activity_tasks_from_completion_are_delivered() {
     // Clone it to move into the callback below
     let num_eager_requested_clone = num_eager_requested.clone();
 
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     mock.expect_complete_workflow_task()
         .times(1)
         .returning(move |req| {
@@ -876,7 +876,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
     t.add_full_wf_task();
     t.add_workflow_execution_completed();
 
-    let mut mock = mock_workflow_client();
+    let mut mock = mock_worker_client();
     // Set up two tasks to be returned via normal activity polling
     let act_tasks = VecDeque::from(vec![
         PollActivityTaskQueueResponse {
@@ -1004,7 +1004,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
 
 #[tokio::test]
 async fn retryable_net_error_exhaustion_is_nonfatal() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_complete_activity_task()
         .times(1)
@@ -1033,7 +1033,7 @@ async fn retryable_net_error_exhaustion_is_nonfatal() {
 
 #[tokio::test]
 async fn cant_complete_activity_with_unset_result_payload() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_poll_activity_task()
         .returning(move |_, _| {
@@ -1076,7 +1076,7 @@ async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
         .times(1)
         .returning(move || None);
     // They shall all be reported as failed
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     mock_client
         .expect_fail_activity_task()
         .times(3)
@@ -1153,7 +1153,7 @@ async fn activities_must_be_flushed_to_server_on_shutdown(#[values(true, false)]
         .expect_poll()
         .times(1)
         .returning(move || None);
-    let mut mock_client = mock_manual_workflow_client();
+    let mut mock_client = mock_manual_worker_client();
     mock_client
         .expect_complete_activity_task()
         .times(1)
@@ -1251,7 +1251,7 @@ async fn pass_activity_summary_to_metadata() {
 
 #[tokio::test]
 async fn heartbeat_response_can_be_paused() {
-    let mut mock_client = mock_workflow_client();
+    let mut mock_client = mock_worker_client();
     // First heartbeat returns pause only
     mock_client
         .expect_record_activity_heartbeat()