@temporalio/core-bridge 1.3.0 → 1.4.0

package/sdk-core/client/Cargo.toml

@@ -20,7 +20,7 @@ futures = "0.3"
 futures-retry = "0.6.0"
 http = "0.2"
 once_cell = "1.13"
-opentelemetry = { version = "0.17", features = ["metrics"] }
+opentelemetry = { version = "0.18", features = ["metrics"] }
 parking_lot = "0.12"
 prost-types = "0.11"
 thiserror = "1.0"

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

@@ -29,7 +29,7 @@ use crate::{
     sealed::WfHandleClient,
     workflow_handle::UntypedWorkflowHandle,
 };
-use backoff::{ExponentialBackoff, SystemClock};
+use backoff::{exponential, ExponentialBackoff, SystemClock};
 use http::uri::InvalidUri;
 use once_cell::sync::OnceCell;
 use opentelemetry::metrics::Meter;
@@ -73,6 +73,7 @@ use uuid::Uuid;
 
 static CLIENT_NAME_HEADER_KEY: &str = "client-name";
 static CLIENT_VERSION_HEADER_KEY: &str = "client-version";
+/// These must match the gRPC method names, not the snake case versions that exist in the Rust code.
 static LONG_POLL_METHOD_NAMES: [&str; 2] = ["PollWorkflowTaskQueue", "PollActivityTaskQueue"];
 /// The server times out polls after 60 seconds. Set our timeout to be slightly beyond that.
 const LONG_POLL_TIMEOUT: Duration = Duration::from_secs(70);
@@ -179,20 +180,24 @@ impl RetryConfig {
             max_retries: 0,
         }
     }
+
+    pub(crate) fn into_exp_backoff<C>(self, clock: C) -> exponential::ExponentialBackoff<C> {
+        exponential::ExponentialBackoff {
+            current_interval: self.initial_interval,
+            initial_interval: self.initial_interval,
+            randomization_factor: self.randomization_factor,
+            multiplier: self.multiplier,
+            max_interval: self.max_interval,
+            max_elapsed_time: self.max_elapsed_time,
+            clock,
+            start_time: Instant::now(),
+        }
+    }
 }
 
 impl From<RetryConfig> for ExponentialBackoff {
     fn from(c: RetryConfig) -> Self {
-        Self {
-            current_interval: c.initial_interval,
-            initial_interval: c.initial_interval,
-            randomization_factor: c.randomization_factor,
-            multiplier: c.multiplier,
-            max_interval: c.max_interval,
-            max_elapsed_time: c.max_elapsed_time,
-            clock: SystemClock::default(),
-            start_time: Instant::now(),
-        }
+        c.into_exp_backoff(SystemClock::default())
     }
 }
 

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

@@ -1,7 +1,7 @@
 use crate::{AttachMetricLabels, LONG_POLL_METHOD_NAMES};
 use futures::{future::BoxFuture, FutureExt};
 use opentelemetry::{
-    metrics::{Counter, Meter, ValueRecorder},
+    metrics::{Counter, Histogram, Meter},
     KeyValue,
 };
 use std::{
@@ -17,6 +17,7 @@ use tower::Service;
 // appropriate k/vs have already been set.
 #[derive(Clone, Debug)]
 pub struct MetricsContext {
+    ctx: opentelemetry::Context,
     kvs: Arc<Vec<KeyValue>>,
     poll_is_long: bool,
 
@@ -25,21 +26,22 @@ pub struct MetricsContext {
     long_svc_request: Counter<u64>,
     long_svc_request_failed: Counter<u64>,
 
-    svc_request_latency: ValueRecorder<u64>,
-    long_svc_request_latency: ValueRecorder<u64>,
+    svc_request_latency: Histogram<u64>,
+    long_svc_request_latency: Histogram<u64>,
 }
 
 impl MetricsContext {
     pub(crate) fn new(kvs: Vec<KeyValue>, meter: &Meter) -> Self {
         Self {
+            ctx: opentelemetry::Context::current(),
             kvs: Arc::new(kvs),
             poll_is_long: false,
             svc_request: meter.u64_counter("request").init(),
             svc_request_failed: meter.u64_counter("request_failure").init(),
             long_svc_request: meter.u64_counter("long_request").init(),
             long_svc_request_failed: meter.u64_counter("long_request_failure").init(),
-            svc_request_latency: meter.u64_value_recorder("request_latency").init(),
-            long_svc_request_latency: meter.u64_value_recorder("long_request_latency").init(),
+            svc_request_latency: meter.u64_histogram("request_latency").init(),
+            long_svc_request_latency: meter.u64_histogram("long_request_latency").init(),
         }
     }
 
@@ -62,18 +64,18 @@ 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.long_svc_request.add(&self.ctx, 1, &self.kvs);
         } else {
-            self.svc_request.add(1, &self.kvs);
+            self.svc_request.add(&self.ctx, 1, &self.kvs);
         }
     }
 
     /// A request to the temporal service failed
     pub(crate) fn svc_request_failed(&self) {
         if self.poll_is_long {
-            self.long_svc_request_failed.add(1, &self.kvs);
+            self.long_svc_request_failed.add(&self.ctx, 1, &self.kvs);
         } else {
-            self.svc_request_failed.add(1, &self.kvs);
+            self.svc_request_failed.add(&self.ctx, 1, &self.kvs);
         }
     }
 
@@ -81,10 +83,10 @@ impl MetricsContext {
     pub(crate) fn record_svc_req_latency(&self, dur: Duration) {
         if self.poll_is_long {
             self.long_svc_request_latency
-                .record(dur.as_millis() as u64, &self.kvs);
+                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
         } else {
             self.svc_request_latency
-                .record(dur.as_millis() as u64, &self.kvs);
+                .record(&self.ctx, dur.as_millis() as u64, &self.kvs);
         }
     }
 }

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

@@ -95,7 +95,6 @@ where
         F: Send + Sync + Unpin + 'static,
     {
         let rtc = self.get_retry_config(call_name);
-        let req = req_cloner(&req);
         let fact = || {
             let req_clone = req_cloner(&req);
             callfn(self, req_clone)
@@ -892,7 +891,7 @@ mod tests {
             .filter(|l| l.starts_with("rpc"))
             .map(|l| {
                 let stripped = l.strip_prefix("rpc ").unwrap();
-                (&stripped[..stripped.find('(').unwrap()]).trim()
+                (stripped[..stripped.find('(').unwrap()]).trim()
             })
             .collect();
         let no_underscores: HashSet<_> = impl_list.iter().map(|x| x.replace('_', "")).collect();

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

@@ -29,6 +29,10 @@ pub const RETRYABLE_ERROR_CODES: [Code; 7] = [
     Code::Unavailable,
 ];
 const LONG_POLL_FATAL_GRACE: Duration = Duration::from_secs(60);
+/// Must match the method name in [crate::raw::WorkflowService]
+const POLL_WORKFLOW_METH_NAME: &str = "poll_workflow_task_queue";
+/// Must match the method name in [crate::raw::WorkflowService]
+const POLL_ACTIVITY_METH_NAME: &str = "poll_activity_task_queue";
 
 /// A wrapper for a [WorkflowClientTrait] or [crate::WorkflowService] implementor which performs
 /// auto-retries
@@ -82,8 +86,7 @@ impl<SG> RetryClient<SG> {
     }
 
     pub(crate) fn get_retry_config(&self, call_name: &'static str) -> RetryConfig {
-        let call_type = Self::determine_call_type(call_name);
-        match call_type {
+        match CallType::from_call_name(call_name) {
             CallType::Normal => (*self.retry_config).clone(),
             CallType::LongPoll => RetryConfig::poll_retry_policy(),
         }
@@ -98,15 +101,7 @@ impl<SG> RetryClient<SG> {
         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,
-        }
+        FutureRetry::new(factory, TonicErrorHandler::new(rtc, call_name))
     }
 }
 
@@ -118,19 +113,22 @@ pub(crate) struct TonicErrorHandler<C: Clock> {
     call_name: &'static str,
 }
 impl TonicErrorHandler<SystemClock> {
-    fn new(cfg: RetryConfig, call_type: CallType, call_name: &'static str) -> Self {
-        Self {
-            max_retries: cfg.max_retries,
-            call_type,
-            call_name,
-            backoff: cfg.into(),
-        }
+    fn new(cfg: RetryConfig, call_name: &'static str) -> Self {
+        Self::new_with_clock(cfg, call_name, SystemClock::default())
     }
 }
 impl<C> TonicErrorHandler<C>
 where
     C: Clock,
 {
+    fn new_with_clock(cfg: RetryConfig, call_name: &'static str, clock: C) -> Self {
+        Self {
+            max_retries: cfg.max_retries,
+            call_type: CallType::from_call_name(call_name),
+            call_name,
+            backoff: cfg.into_exp_backoff(clock),
+        }
+    }
     const fn should_log_retry_warning(&self, cur_attempt: usize) -> bool {
         // Warn on more than 5 retries for unlimited retrying
         if self.max_retries == 0 && cur_attempt > 5 {
@@ -149,6 +147,14 @@ pub enum CallType {
     Normal,
     LongPoll,
 }
+impl CallType {
+    fn from_call_name(call_name: &str) -> Self {
+        match call_name {
+            POLL_WORKFLOW_METH_NAME | POLL_ACTIVITY_METH_NAME => CallType::LongPoll,
+            _ => CallType::Normal,
+        }
+    }
+}
 
 impl<C> ErrorHandler<tonic::Status> for TonicErrorHandler<C>
 where
@@ -568,22 +574,13 @@ mod tests {
             Code::Unauthenticated,
             Code::Unimplemented,
         ] {
-            for call_name in ["poll_workflow_task", "poll_activity_task"] {
-                let retry_cfg = RetryConfig::default();
+            for call_name in [POLL_WORKFLOW_METH_NAME, POLL_ACTIVITY_METH_NAME] {
+                let retry_cfg = RetryConfig::poll_retry_policy();
                 let mut err_handler = TonicErrorHandler {
                     max_retries: retry_cfg.max_retries,
                     call_type: CallType::LongPoll,
                     call_name,
-                    backoff: ExponentialBackoff {
-                        current_interval: retry_cfg.initial_interval,
-                        initial_interval: retry_cfg.initial_interval,
-                        randomization_factor: retry_cfg.randomization_factor,
-                        multiplier: retry_cfg.multiplier,
-                        max_interval: retry_cfg.max_interval,
-                        max_elapsed_time: retry_cfg.max_elapsed_time,
-                        clock: FixedClock(Instant::now()),
-                        start_time: Instant::now(),
-                    },
+                    backoff: retry_cfg.into_exp_backoff(FixedClock(Instant::now())),
                 };
                 let result = err_handler.handle(1, Status::new(code, "Ahh"));
                 assert_matches!(result, RetryPolicy::WaitRetry(_));
@@ -598,6 +595,30 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn long_poll_retryable_errors_never_fatal() {
+        for code in RETRYABLE_ERROR_CODES {
+            for call_name in [POLL_WORKFLOW_METH_NAME, POLL_ACTIVITY_METH_NAME] {
+                let retry_cfg = RetryConfig::poll_retry_policy();
+                let mut err_handler = TonicErrorHandler {
+                    max_retries: retry_cfg.max_retries,
+                    call_type: CallType::LongPoll,
+                    call_name,
+                    backoff: retry_cfg.into_exp_backoff(FixedClock(Instant::now())),
+                };
+                let result = err_handler.handle(1, Status::new(code, "Ahh"));
+                assert_matches!(result, RetryPolicy::WaitRetry(_));
+                err_handler.backoff.clock.0 = err_handler
+                    .backoff
+                    .clock
+                    .0
+                    .add(LONG_POLL_FATAL_GRACE + Duration::from_secs(1));
+                let result = err_handler.handle(2, Status::new(code, "Ahh"));
+                assert_matches!(result, RetryPolicy::WaitRetry(_));
+            }
+        }
+    }
+
     #[tokio::test]
     async fn retryable_errors() {
         for code in RETRYABLE_ERROR_CODES {
@@ -626,12 +647,9 @@ mod tests {
         // correct retry config
         let fake_retry = RetryClient::new((), Default::default());
         for i in 1..=50 {
-            for call in ["poll_workflow_task", "poll_activity_task"] {
-                let mut err_handler = TonicErrorHandler::new(
-                    fake_retry.get_retry_config(call),
-                    CallType::LongPoll,
-                    call,
-                );
+            for call in [POLL_WORKFLOW_METH_NAME, POLL_ACTIVITY_METH_NAME] {
+                let mut err_handler =
+                    TonicErrorHandler::new(fake_retry.get_retry_config(call), call);
                 let result = err_handler.handle(i, Status::new(Code::Unknown, "Ahh"));
                 assert_matches!(result, RetryPolicy::WaitRetry(_));
             }
@@ -643,12 +661,9 @@ mod tests {
         let fake_retry = RetryClient::new((), Default::default());
         // For some reason we will get cancelled in these situations occasionally (always?) too
         for code in [Code::Cancelled, Code::DeadlineExceeded] {
-            for call in ["poll_workflow_task", "poll_activity_task"] {
-                let mut err_handler = TonicErrorHandler::new(
-                    fake_retry.get_retry_config(call),
-                    CallType::LongPoll,
-                    call,
-                );
+            for call in [POLL_WORKFLOW_METH_NAME, POLL_ACTIVITY_METH_NAME] {
+                let mut err_handler =
+                    TonicErrorHandler::new(fake_retry.get_retry_config(call), call);
                 for i in 1..=5 {
                     let result = err_handler.handle(i, Status::new(code, "retryable failure"));
                     assert_matches!(result, RetryPolicy::WaitRetry(_));

package/sdk-core/core/Cargo.toml

@@ -26,7 +26,7 @@ enum_dispatch = "0.3"
 flate2 = "1.0"
 futures = "0.3"
 futures-util = "0.3"
-governor = "0.4"
+governor = "0.5"
 http = "0.2"
 hyper = "0.14"
 itertools = "0.10"
@@ -36,9 +36,9 @@ lru = "0.8"
 mockall = "0.11"
 nix = "0.25"
 once_cell = "1.5"
-opentelemetry = { version = "0.17", features = ["rt-tokio"] }
-opentelemetry-otlp = { version = "0.10.0", features = ["tokio", "metrics"] }
-opentelemetry-prometheus = "0.10.0"
+opentelemetry = { version = "0.18", features = ["rt-tokio"] }
+opentelemetry-otlp = { version = "0.11", features = ["tokio", "metrics"] }
+opentelemetry-prometheus = "0.11"
 parking_lot = { version = "0.12", features = ["send_guard"] }
 prometheus = "0.13"
 prost = "0.11"
@@ -56,11 +56,9 @@ tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "
 tokio-util = { version = "0.7", features = ["io", "io-util"] }
 tokio-stream = "0.1"
 tonic = { version = "0.8", features = ["tls", "tls-roots"] }
-# TODO: Get rid of this once otel updates its tonic dep
-tonic_otel = { version = "0.6", package = "tonic" }
 tracing = { version = "0.1", features = ["log-always"] }
 tracing-futures = "0.2"
-tracing-opentelemetry = "0.17"
+tracing-opentelemetry = "0.18"
 tracing-subscriber = { version = "0.3", features = ["parking_lot", "env-filter"] }
 url = "2.2"
 uuid = { version = "1.1", features = ["v4"] }
@@ -87,7 +85,7 @@ version = "0.1"
 [dev-dependencies]
 assert_matches = "1.4"
 bimap = "0.6.1"
-criterion = "0.3"
+criterion = "0.4"
 rstest = "0.15"
 temporal-sdk-core-test-utils = { path = "../test-utils" }
 temporal-sdk = { path = "../sdk" }
@@ -110,3 +108,9 @@ test = false
 [[bench]]
 name = "workflow_replay"
 harness = false
+
+# This is maybe a bit hacky, but we call the runner an "example" because that gets it compiling with
+# the dev-dependencies, which we want.
+[[example]]
+name = "integ_runner"
+path = "../tests/runner.rs"

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

@@ -10,6 +10,7 @@ use crate::{
     ActivityHeartbeat, Worker, WorkerConfigBuilder,
 };
 use futures::FutureExt;
+use itertools::Itertools;
 use std::{
     cell::RefCell,
     collections::{hash_map::Entry, HashMap, VecDeque},
@@ -617,20 +618,23 @@ async fn max_tq_acts_set_passed_to_poll_properly() {
 /// delivered via polling.
 #[tokio::test]
 async fn activity_tasks_from_completion_are_delivered() {
+    // Construct the history - one task with 5 activities, 4 on the same task queue, and 1 on a
+    // different queue, 3 activities will be executed eagerly as specified by the
+    // MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK constant.
     let wfid = "fake_wf_id";
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
-    let act_same_queue_sched_id = t.add_activity_task_scheduled("act_id_same_queue");
-    let act_different_queue_sched_id = t.add_activity_task_scheduled("act_id_different_queue");
-    let act_same_queue_start_id = t.add_activity_task_started(act_same_queue_sched_id);
-    t.add_activity_task_completed(
-        act_same_queue_sched_id,
-        act_same_queue_start_id,
-        b"hi".into(),
-    );
+    let act_same_queue_scheduled_ids = (1..4)
+        .map(|i| t.add_activity_task_scheduled(format!("act_id_{}_same_queue", i)))
+        .collect_vec();
+    t.add_activity_task_scheduled("act_id_same_queue_not_eager");
+    t.add_activity_task_scheduled("act_id_different_queue");
+    for scheduled_event_id in act_same_queue_scheduled_ids {
+        let started_event_id = t.add_activity_task_started(scheduled_event_id);
+        t.add_activity_task_completed(scheduled_event_id, started_event_id, b"hi".into());
+    }
     t.add_full_wf_task();
-    t.add_activity_task_cancel_requested(act_different_queue_sched_id);
     t.add_workflow_execution_completed();
 
     let num_eager_requested = Arc::new(AtomicUsize::new(0));
@@ -658,15 +662,17 @@ async fn activity_tasks_from_completion_are_delivered() {
             num_eager_requested_clone.store(count, Ordering::Relaxed);
             Ok(RespondWorkflowTaskCompletedResponse {
                 workflow_task: None,
-                activity_tasks: vec![PollActivityTaskQueueResponse {
-                    task_token: vec![1],
-                    activity_id: "act_id_same_queue".to_string(),
-                    ..Default::default()
-                }],
+                activity_tasks: (1..4)
+                    .map(|i| PollActivityTaskQueueResponse {
+                        task_token: vec![i],
+                        activity_id: format!("act_id_{}_same_queue", i),
+                        ..Default::default()
+                    })
+                    .collect_vec(),
             })
         });
     mock.expect_complete_activity_task()
-        .times(1)
+        .times(3)
         .returning(|_, _| Ok(RespondActivityTaskCompletedResponse::default()));
     let mut mock = single_hist_mock_sg(wfid, t, [1], mock, true);
     let mut mock_poller = mock_manual_poller();
@@ -677,46 +683,65 @@ async fn activity_tasks_from_completion_are_delivered() {
     mock.worker_cfg(|wc| wc.max_cached_workflows = 2);
     let core = mock_worker(mock);
 
+    // Test start
     let wf_task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        wf_task.run_id,
-        vec![
+    let mut cmds = (1..4)
+        .map(|seq| {
             ScheduleActivity {
-                seq: 1,
-                activity_id: "act_id_same_queue".to_string(),
+                seq,
+                activity_id: format!("act_id_{}_same_queue", seq),
                 task_queue: TEST_Q.to_string(),
                 cancellation_type: ActivityCancellationType::TryCancel as i32,
                 ..Default::default()
             }
-            .into(),
-            ScheduleActivity {
-                seq: 2,
-                activity_id: "act_id_different_queue".to_string(),
-                task_queue: "different_queue".to_string(),
-                cancellation_type: ActivityCancellationType::Abandon as i32,
-                ..Default::default()
-            }
-            .into(),
-        ],
+            .into()
+        })
+        .collect_vec();
+    cmds.push(
+        ScheduleActivity {
+            seq: 4,
+            activity_id: "act_id_same_queue_not_eager".to_string(),
+            task_queue: TEST_Q.to_string(),
+            cancellation_type: ActivityCancellationType::TryCancel as i32,
+            ..Default::default()
+        }
+        .into(),
+    );
+    cmds.push(
+        ScheduleActivity {
+            seq: 5,
+            activity_id: "act_id_different_queue".to_string(),
+            task_queue: "different_queue".to_string(),
+            cancellation_type: ActivityCancellationType::Abandon as i32,
+            ..Default::default()
+        }
+        .into(),
+    );
+
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        wf_task.run_id,
+        cmds,
     ))
     .await
     .unwrap();
 
-    // We should see the activity when we poll now
-    let act_task = core.poll_activity_task().await.unwrap();
-    assert_eq!(act_task.task_token, vec![1]);
+    // We should see the 3 eager activities when we poll now
+    for i in 1..4 {
+        let act_task = core.poll_activity_task().await.unwrap();
+        assert_eq!(act_task.task_token, vec![i]);
 
-    core.complete_activity_task(ActivityTaskCompletion {
-        task_token: act_task.task_token.clone(),
-        result: Some(ActivityExecutionResult::ok("hi".into())),
-    })
-    .await
-    .unwrap();
+        core.complete_activity_task(ActivityTaskCompletion {
+            task_token: act_task.task_token.clone(),
+            result: Some(ActivityExecutionResult::ok("hi".into())),
+        })
+        .await
+        .unwrap();
+    }
 
     core.shutdown().await;
 
     // Verify only a single eager activity was scheduled (the one on our worker's task queue)
-    assert_eq!(num_eager_requested.load(Ordering::Relaxed), 1);
+    assert_eq!(num_eager_requested.load(Ordering::Relaxed), 3);
 }
 
 #[tokio::test]

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

@@ -20,6 +20,7 @@ use zip::read::read_zipfile_from_stream;
 
 #[cfg(target_family = "unix")]
 use std::os::unix::fs::OpenOptionsExt;
+use std::process::Stdio;
 
 /// Configuration for Temporalite.
 #[derive(Debug, Clone, derive_builder::Builder)]
@@ -52,6 +53,11 @@ pub struct TemporaliteConfig {
 impl TemporaliteConfig {
     /// Start a Temporalite server.
     pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        self.start_server_with_output(Stdio::inherit()).await
+    }
+
+    /// Start a Temporalite server with configurable stdout destination.
+    pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
         let exe_path = self.exe.get_or_download("temporalite").await?;
 
@@ -89,6 +95,7 @@ impl TemporaliteConfig {
             port,
             args,
             has_test_service: false,
+            output,
         })
         .await
     }
@@ -110,6 +117,11 @@ pub struct TestServerConfig {
 impl TestServerConfig {
     /// Start a test server.
     pub async fn start_server(&self) -> anyhow::Result<EphemeralServer> {
+        self.start_server_with_output(Stdio::inherit()).await
+    }
+
+    /// Start a test server with configurable stdout.
+    pub async fn start_server_with_output(&self, output: Stdio) -> anyhow::Result<EphemeralServer> {
         // Get exe path
         let exe_path = self.exe.get_or_download("temporal-test-server").await?;
 
@@ -126,6 +138,7 @@ impl TestServerConfig {
             port,
             args,
             has_test_service: true,
+            output,
         })
         .await
     }
@@ -136,9 +149,11 @@ struct EphemeralServerConfig {
     port: u16,
     args: Vec<String>,
     has_test_service: bool,
+    output: Stdio,
 }
 
 /// Server that will be stopped when dropped.
+#[derive(Debug)]
 pub struct EphemeralServer {
     /// gRPC target host:port for the server frontend.
     pub target: String,
@@ -153,7 +168,8 @@ impl EphemeralServer {
         // TODO(cretz): Offer stdio suppression?
         let child = tokio::process::Command::new(config.exe_path)
             .args(config.args)
-            .stdin(std::process::Stdio::null())
+            .stdin(Stdio::null())
+            .stdout(config.output)
             .spawn()?;
         let target = format!("127.0.0.1:{}", config.port);
         let target_url = format!("http://{}", target);
@@ -208,12 +224,12 @@ impl EphemeralServer {
         // For whatever reason, Tokio is not properly waiting on result
         // after sending kill in some cases which is causing defunct zombie
         // processes to remain and kill() to hang. Therefore, we are sending
-        // SIGINT and waiting on the process ourselves using a low-level call.
+        // SIGKILL and waiting on the process ourselves using a low-level call.
         //
         // WARNING: This is based on empirical evidence starting a Python test
         // run on Linux with Python 3.7 (does not happen on Python 3.10 nor does
         // it happen on Temporalite nor does it happen in Rust integration
-        // tests). Do not consider this fixed without running that scenario.
+        // tests). Don't alter without running that scenario. EX: SIGINT works but not SIGKILL
         if let Some(pid) = self.child.id() {
             let nix_pid = nix::unistd::Pid::from_raw(pid as i32);
             Ok(spawn_blocking(move || {

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

@@ -34,8 +34,8 @@ pub use pollers::{
     TlsConfig, WorkflowClientTrait,
 };
 pub use telemetry::{
-    fetch_global_buffered_logs, telemetry_init, Logger, MetricsExporter, OtelCollectorOptions,
-    TelemetryOptions, TelemetryOptionsBuilder, TraceExporter,
+    fetch_global_buffered_logs, telemetry_init, Logger, MetricTemporality, MetricsExporter,
+    OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder, TraceExporter,
 };
 pub use temporal_sdk_core_api as api;
 pub use temporal_sdk_core_protos as protos;

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

@@ -19,6 +19,7 @@ pub type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 /// A trait for things that poll the server. Hides complexity of concurrent polling or polling
 /// on sticky/nonsticky queues simultaneously.
 #[cfg_attr(test, mockall::automock)]
+#[cfg_attr(test, allow(unused))]
 #[async_trait::async_trait]
 pub trait Poller<PollResult>
 where
@@ -37,6 +38,7 @@ pub type BoxedActPoller = BoxedPoller<PollActivityTaskQueueResponse>;
 #[cfg(test)]
 mockall::mock! {
     pub ManualPoller<T: Send + Sync + 'static> {}
+    #[allow(unused)]
     impl<T: Send + Sync + 'static> Poller<T> for ManualPoller<T> {
         fn poll<'a, 'b>(&self)
           -> impl Future<Output = Option<Result<T>>> + Send + 'b