@temporalio/core-bridge 1.3.0 → 1.4.0

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

@@ -1,15 +1,17 @@
 use super::TELEM_SERVICE_NAME;
 use crate::telemetry::GLOBAL_TELEM_DAT;
+use opentelemetry::sdk::metrics::aggregators::Aggregator;
+use opentelemetry::sdk::metrics::sdk_api::{Descriptor, InstrumentKind};
 use opentelemetry::{
     global,
-    metrics::{Counter, Descriptor, InstrumentKind, Meter, ValueRecorder},
+    metrics::{Counter, Histogram, Meter},
     sdk::{
-        export::metrics::{Aggregator, AggregatorSelector},
+        export::metrics::AggregatorSelector,
         metrics::aggregators::{histogram, last_value, sum},
     },
-    KeyValue,
+    Context, KeyValue,
 };
-use std::{borrow::Cow, sync::Arc, time::Duration};
+use std::{sync::Arc, time::Duration};
 
 /// Used to track context associated with metrics, and record/update them
 ///
@@ -17,12 +19,16 @@ use std::{borrow::Cow, sync::Arc, time::Duration};
 /// appropriate k/vs have already been set.
 #[derive(Default, Clone, Debug)]
 pub(crate) struct MetricsContext {
+    ctx: Context,
     kvs: Arc<Vec<KeyValue>>,
 }
 
 impl MetricsContext {
     fn new(kvs: Vec<KeyValue>) -> Self {
-        Self { kvs: Arc::new(kvs) }
+        Self {
+            ctx: Context::current(),
+            kvs: Arc::new(kvs),
+        }
     }
 
     pub(crate) fn top_level(namespace: String) -> Self {
@@ -38,113 +44,116 @@ impl MetricsContext {
     pub(crate) fn with_new_attrs(&self, new_kvs: impl IntoIterator<Item = KeyValue>) -> Self {
         let mut kvs = self.kvs.clone();
         Arc::make_mut(&mut kvs).extend(new_kvs);
-        Self { kvs }
+        Self {
+            ctx: Context::current(),
+            kvs,
+        }
     }
 
     /// A workflow task queue poll succeeded
     pub(crate) fn wf_tq_poll_ok(&self) {
-        WF_TASK_QUEUE_POLL_SUCCEED_COUNTER.add(1, &self.kvs);
+        WF_TASK_QUEUE_POLL_SUCCEED_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow task queue poll timed out / had empty response
     pub(crate) fn wf_tq_poll_empty(&self) {
-        WF_TASK_QUEUE_POLL_EMPTY_COUNTER.add(1, &self.kvs);
+        WF_TASK_QUEUE_POLL_EMPTY_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow task execution failed
     pub(crate) fn wf_task_failed(&self) {
-        WF_TASK_EXECUTION_FAILURE_COUNTER.add(1, &self.kvs);
+        WF_TASK_EXECUTION_FAILURE_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow completed successfully
     pub(crate) fn wf_completed(&self) {
-        WF_COMPLETED_COUNTER.add(1, &self.kvs);
+        WF_COMPLETED_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow ended cancelled
     pub(crate) fn wf_canceled(&self) {
-        WF_CANCELED_COUNTER.add(1, &self.kvs);
+        WF_CANCELED_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow ended failed
     pub(crate) fn wf_failed(&self) {
-        WF_FAILED_COUNTER.add(1, &self.kvs);
+        WF_FAILED_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow continued as new
     pub(crate) fn wf_continued_as_new(&self) {
-        WF_CONT_COUNTER.add(1, &self.kvs);
+        WF_CONT_COUNTER.add(&self.ctx, 1, &self.kvs);
     }
 
     /// Record workflow total execution time in milliseconds
     pub(crate) fn wf_e2e_latency(&self, dur: Duration) {
-        WF_E2E_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        WF_E2E_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// Record workflow task schedule to start time in millis
     pub(crate) fn wf_task_sched_to_start_latency(&self, dur: Duration) {
-        WF_TASK_SCHED_TO_START_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        WF_TASK_SCHED_TO_START_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// Record workflow task execution time in milliseconds
     pub(crate) fn wf_task_latency(&self, dur: Duration) {
-        WF_TASK_EXECUTION_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        WF_TASK_EXECUTION_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// Record time it takes to catch up on replaying a WFT
     pub(crate) fn wf_task_replay_latency(&self, dur: Duration) {
-        WF_TASK_REPLAY_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        WF_TASK_REPLAY_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// An activity long poll timed out
     pub(crate) fn act_poll_timeout(&self) {
-        ACT_POLL_NO_TASK.add(1, &self.kvs);
+        ACT_POLL_NO_TASK.add(&self.ctx, 1, &self.kvs);
     }
 
     /// An activity execution failed
     pub(crate) fn act_execution_failed(&self) {
-        ACT_EXECUTION_FAILED.add(1, &self.kvs);
+        ACT_EXECUTION_FAILED.add(&self.ctx, 1, &self.kvs);
     }
 
     /// Record activity task schedule to start time in millis
     pub(crate) fn act_sched_to_start_latency(&self, dur: Duration) {
-        ACT_SCHED_TO_START_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        ACT_SCHED_TO_START_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// Record time it took to complete activity execution, from the time core generated the
     /// activity task, to the time lang responded with a completion (failure or success).
     pub(crate) fn act_execution_latency(&self, dur: Duration) {
-        ACT_EXEC_LATENCY.record(dur.as_millis() as u64, &self.kvs);
+        ACT_EXEC_LATENCY.record(&self.ctx, dur.as_millis() as u64, &self.kvs);
     }
 
     /// A worker was registered
     pub(crate) fn worker_registered(&self) {
-        WORKER_REGISTERED.add(1, &self.kvs);
+        WORKER_REGISTERED.add(&self.ctx, 1, &self.kvs);
     }
 
     /// Record current number of available task slots. Context should have worker type set.
     pub(crate) fn available_task_slots(&self, num: usize) {
-        TASK_SLOTS_AVAILABLE.record(num as u64, &self.kvs)
+        TASK_SLOTS_AVAILABLE.record(&self.ctx, num as u64, &self.kvs)
     }
 
     /// Record current number of pollers. Context should include poller type / task queue tag.
     pub(crate) fn record_num_pollers(&self, num: usize) {
-        NUM_POLLERS.record(num as u64, &self.kvs);
+        NUM_POLLERS.record(&self.ctx, num as u64, &self.kvs);
     }
 
     /// A workflow task found a cached workflow to run against
     pub(crate) fn sticky_cache_hit(&self) {
-        STICKY_CACHE_HIT.add(1, &self.kvs);
+        STICKY_CACHE_HIT.add(&self.ctx, 1, &self.kvs);
     }
 
     /// A workflow task did not find a cached workflow
     pub(crate) fn sticky_cache_miss(&self) {
-        STICKY_CACHE_MISS.add(1, &self.kvs);
+        STICKY_CACHE_MISS.add(&self.ctx, 1, &self.kvs);
     }
 
     /// Record current cache size (in number of wfs, not bytes)
     pub(crate) fn cache_size(&self, size: u64) {
-        STICKY_CACHE_SIZE.record(size, &self.kvs);
+        STICKY_CACHE_SIZE.record(&self.ctx, size, &self.kvs);
     }
 }
 
@@ -182,8 +191,8 @@ macro_rules! tm {
     };
     (vr_u64, $ident:ident, $name:expr) => {
         lazy_static::lazy_static! {
-            static ref $ident: ValueRecorder<u64> = {
-                METRIC_METER.u64_value_recorder(metric_prefix().to_string() + $name).init()
+            static ref $ident: Histogram<u64> = {
+                METRIC_METER.u64_histogram(metric_prefix().to_string() + $name).init()
             };
         }
     };
@@ -214,22 +223,22 @@ pub(crate) fn activity_type(ty: String) -> KeyValue {
 pub(crate) fn workflow_type(ty: String) -> KeyValue {
     KeyValue::new(KEY_WF_TYPE, ty)
 }
-pub(crate) const fn workflow_worker_type() -> KeyValue {
+pub(crate) fn workflow_worker_type() -> KeyValue {
     KeyValue {
         key: opentelemetry::Key::from_static_str(KEY_WORKER_TYPE),
-        value: opentelemetry::Value::String(Cow::Borrowed("WorkflowWorker")),
+        value: opentelemetry::Value::String("WorkflowWorker".into()),
     }
 }
-pub(crate) const fn activity_worker_type() -> KeyValue {
+pub(crate) fn activity_worker_type() -> KeyValue {
     KeyValue {
         key: opentelemetry::Key::from_static_str(KEY_WORKER_TYPE),
-        value: opentelemetry::Value::String(Cow::Borrowed("ActivityWorker")),
+        value: opentelemetry::Value::String("ActivityWorker".into()),
     }
 }
-pub(crate) const fn local_activity_worker_type() -> KeyValue {
+pub(crate) fn local_activity_worker_type() -> KeyValue {
     KeyValue {
         key: opentelemetry::Key::from_static_str(KEY_WORKER_TYPE),
-        value: opentelemetry::Value::String(Cow::Borrowed("LocalActivityWorker")),
+        value: opentelemetry::Value::String("LocalActivityWorker".into()),
     }
 }
 
@@ -338,12 +347,12 @@ pub struct SDKAggSelector;
 
 impl AggregatorSelector for SDKAggSelector {
     fn aggregator_for(&self, descriptor: &Descriptor) -> Option<Arc<dyn Aggregator + Send + Sync>> {
-        // Observers are always last value
-        if *descriptor.instrument_kind() == InstrumentKind::ValueObserver {
+        // Gauges are always last value
+        if *descriptor.instrument_kind() == InstrumentKind::GaugeObserver {
             return Some(Arc::new(last_value()));
         }
 
-        if *descriptor.instrument_kind() == InstrumentKind::ValueRecorder {
+        if *descriptor.instrument_kind() == InstrumentKind::Histogram {
             let dname = descriptor
                 .name()
                 .strip_prefix(metric_prefix())
@@ -366,7 +375,7 @@ impl AggregatorSelector for SDKAggSelector {
                 ACT_EXEC_LATENCY_NAME => ACT_EXE_MS_BUCKETS,
                 _ => DEFAULT_MS_BUCKETS,
             };
-            return Some(Arc::new(histogram(descriptor, buckets)));
+            return Some(Arc::new(histogram(buckets)));
         }
 
         Some(Arc::new(sum()))

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

@@ -12,8 +12,12 @@ use once_cell::sync::OnceCell;
 use opentelemetry::{
     global,
     metrics::Meter,
-    sdk::{metrics::PushController, trace::Config, Resource},
-    util::tokio_interval_stream,
+    runtime,
+    sdk::{
+        export::metrics::aggregation::{self, Temporality, TemporalitySelector},
+        trace::Config,
+        Resource,
+    },
     KeyValue,
 };
 use opentelemetry_otlp::WithExportConfig;
@@ -25,6 +29,7 @@ use std::{
     time::Duration,
 };
 use temporal_sdk_core_api::CoreTelemetry;
+use tonic::metadata::MetadataMap;
 use tracing_subscriber::{filter::ParseError, layer::SubscriberExt, EnvFilter};
 use url::Url;
 
@@ -68,7 +73,7 @@ pub enum MetricsExporter {
 }
 
 /// Control where logs go
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum Logger {
     /// Log directly to console.
     Console,
@@ -100,6 +105,33 @@ pub struct TelemetryOptions {
     /// the prefix is consistent with other SDKs.
     #[builder(default)]
     pub no_temporal_prefix_for_metrics: bool,
+
+    /// Specifies the aggregation temporality for metric export. Defaults to cumulative.
+    #[builder(default = "MetricTemporality::Cumulative")]
+    pub metric_temporality: MetricTemporality,
+}
+
+/// Types of aggregation temporality for metric export.
+/// See: <https://github.com/open-telemetry/opentelemetry-specification/blob/ce50e4634efcba8da445cc23523243cb893905cb/specification/metrics/datamodel.md#temporality>
+#[derive(Debug, Clone, Copy)]
+pub enum MetricTemporality {
+    /// Successive data points repeat the starting timestamp
+    Cumulative,
+    /// Successive data points advance the starting timestamp
+    Delta,
+}
+
+impl MetricTemporality {
+    fn to_selector(self) -> impl TemporalitySelector + Send + Sync + Clone {
+        match self {
+            MetricTemporality::Cumulative => {
+                aggregation::constant_temporality_selector(Temporality::Cumulative)
+            }
+            MetricTemporality::Delta => {
+                aggregation::constant_temporality_selector(Temporality::Delta)
+            }
+        }
+    }
 }
 
 impl TelemetryOptions {
@@ -122,7 +154,6 @@ impl Default for TelemetryOptions {
 /// Things that need to not be dropped while telemetry is ongoing
 #[derive(Default)]
 pub struct GlobalTelemDat {
-    metric_push_controller: Option<PushController>,
     core_export_logger: Option<CoreExportLogger>,
     runtime: Option<tokio::runtime::Runtime>,
     prom_srv: Option<PromServer>,
@@ -201,7 +232,7 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
                                 .pretty()
                                 .with_source_location(false);
                             let reg = tracing_subscriber::registry()
-                                .with((&opts).try_get_env_filter()?)
+                                .with((opts).try_get_env_filter()?)
                                 .with(
                                     tracing_subscriber::fmt::layer()
                                         .with_target(false)
@@ -220,31 +251,31 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
             if let Some(ref metrics) = opts.metrics {
                 match metrics {
                     MetricsExporter::Prometheus(addr) => {
-                        let srv = PromServer::new(*addr)?;
+                        let srv = PromServer::new(*addr, opts.metric_temporality.to_selector())?;
                         globaldat.prom_srv = Some(srv);
                     }
                     MetricsExporter::Otel(OtelCollectorOptions { url, headers }) => {
                         runtime.block_on(async {
                             let metrics = opentelemetry_otlp::new_pipeline()
-                                .metrics(|f| runtime.spawn(f), tokio_interval_stream)
-                                .with_aggregator_selector(SDKAggSelector)
+                                .metrics(
+                                    SDKAggSelector,
+                                    opts.metric_temporality.to_selector(),
+                                    runtime::Tokio,
+                                )
                                 .with_period(Duration::from_secs(1))
-                                .with_resource(default_resource_kvs().iter().cloned())
+                                .with_resource(default_resource())
                                 .with_exporter(
                                     // No joke exporter builder literally not cloneable for some insane
                                     // reason
                                     opentelemetry_otlp::new_exporter()
                                         .tonic()
                                         .with_endpoint(url.to_string())
-                                        .with_metadata(
-                                            tonic_otel::metadata::MetadataMap::from_headers(
-                                                headers.try_into()?,
-                                            ),
-                                        ),
+                                        .with_metadata(MetadataMap::from_headers(
+                                            headers.try_into()?,
+                                        )),
                                 )
                                 .build()?;
-                            global::set_meter_provider(metrics.provider());
-                            globaldat.metric_push_controller = Some(metrics);
+                            global::set_meter_provider(metrics);
                             Result::<(), anyhow::Error>::Ok(())
                         })?;
                     }
@@ -262,14 +293,12 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
                                     opentelemetry_otlp::new_exporter()
                                         .tonic()
                                         .with_endpoint(url.to_string())
-                                        .with_metadata(
-                                            tonic_otel::metadata::MetadataMap::from_headers(
-                                                headers.try_into()?,
-                                            ),
-                                        ),
+                                        .with_metadata(MetadataMap::from_headers(
+                                            headers.try_into()?,
+                                        )),
                                 )
                                 .with_trace_config(tracer_cfg)
-                                .install_batch(opentelemetry::runtime::Tokio)?;
+                                .install_batch(runtime::Tokio)?;
 
                             let opentelemetry = tracing_opentelemetry::layer().with_tracer(tracer);
 
@@ -334,6 +363,7 @@ pub(crate) fn test_telem_console() {
         tracing: None,
         metrics: None,
         no_temporal_prefix_for_metrics: false,
+        metric_temporality: MetricTemporality::Cumulative,
     })
     .unwrap();
 }
@@ -350,6 +380,7 @@ pub(crate) fn test_telem_collector() {
         })),
         metrics: None,
         no_temporal_prefix_for_metrics: false,
+        metric_temporality: MetricTemporality::Cumulative,
     })
     .unwrap();
 }

package/sdk-core/core/src/telemetry/prometheus_server.rs

@@ -1,13 +1,16 @@
-use crate::telemetry::{
-    default_resource,
-    metrics::{SDKAggSelector, DEFAULT_MS_BUCKETS},
-};
+use crate::telemetry::{default_resource, metrics::SDKAggSelector};
 use hyper::{
     header::CONTENT_TYPE,
     service::{make_service_fn, service_fn},
     Body, Method, Request, Response, Server,
 };
-use opentelemetry::metrics::MetricsError;
+use opentelemetry::{
+    metrics::MetricsError,
+    sdk::{
+        export::metrics::aggregation::TemporalitySelector,
+        metrics::{controllers, processors},
+    },
+};
 use opentelemetry_prometheus::{ExporterBuilder, PrometheusExporter};
 use prometheus::{Encoder, TextEncoder};
 use std::{convert::Infallible, net::SocketAddr, sync::Arc};
@@ -19,14 +22,15 @@ pub(super) struct PromServer {
 }
 
 impl PromServer {
-    pub fn new(addr: SocketAddr) -> Result<Self, MetricsError> {
-        let exporter = ExporterBuilder::default()
-            .with_default_histogram_boundaries(DEFAULT_MS_BUCKETS.to_vec())
-            .with_aggregator_selector(SDKAggSelector)
-            .with_host(addr.ip().to_string())
-            .with_port(addr.port())
-            .with_resource(default_resource())
-            .try_init()?;
+    pub fn new(
+        addr: SocketAddr,
+        temporality: impl TemporalitySelector + Send + Sync + 'static,
+    ) -> Result<Self, MetricsError> {
+        let controller =
+            controllers::basic(processors::factory(SDKAggSelector, temporality).with_memory(true))
+                .with_resource(default_resource())
+                .build();
+        let exporter = ExporterBuilder::new(controller).try_init()?;
         Ok(Self {
             exporter: Arc::new(exporter),
             addr,

package/sdk-core/core/src/worker/client/mocks.rs

@@ -17,6 +17,7 @@ pub(crate) fn mock_manual_workflow_client() -> MockManualWorkerClient {
 // https://github.com/asomers/mockall/issues/189 to be fixed for it to go away.
 mockall::mock! {
     pub ManualWorkerClient {}
+    #[allow(unused)]
     impl WorkerClient for ManualWorkerClient {
         fn poll_workflow_task<'a, 'b>(&'a self, task_queue: String, is_sticky: bool)
             -> impl Future<Output = Result<PollWorkflowTaskQueueResponse>> + Send + 'b

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -78,6 +78,7 @@ use tokio_util::sync::CancellationToken;
 use tracing::Span;
 
 pub(crate) const LEGACY_QUERY_ID: &str = "legacy_query";
+const MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK: usize = 3;
 
 type Result<T, E = WFMachinesError> = result::Result<T, E>;
 type BoxedActivationStream = BoxStream<'static, Result<ActivationOrAuto, PollWfError>>;
@@ -472,7 +473,9 @@ impl Workflows {
                             .as_ref()
                             .map(|q| q.name == self.task_queue)
                             .unwrap_or_default();
-                        if same_task_queue {
+                        if same_task_queue
+                            && reserved.len() < MAX_EAGER_ACTIVITY_RESERVATIONS_PER_WORKFLOW_TASK
+                        {
                             if let Some(p) = at_handle.reserve_slot() {
                                 reserved.push(p);
                             } else {

package/sdk-core/core-api/Cargo.toml

@@ -17,7 +17,7 @@ anyhow = "1.0"
 async-trait = "0.1"
 derive_builder = "0.11"
 log = "0.4"
-opentelemetry = "0.17"
+opentelemetry = "0.18"
 prost-types = "0.11"
 thiserror = "1.0"
 tonic = "0.8"

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

@@ -20,6 +20,7 @@ use temporal_client::{
 };
 use temporal_sdk::{interceptors::WorkerInterceptor, IntoActivityFunc, Worker, WorkflowFunction};
 use temporal_sdk_core::{
+    ephemeral_server::{EphemeralExe, EphemeralExeVersion},
     init_replay_worker, init_worker, telemetry_init, ClientOptions, ClientOptionsBuilder, Logger,
     MetricsExporter, OtelCollectorOptions, TelemetryOptions, TelemetryOptionsBuilder,
     TraceExporter, WorkerConfig, WorkerConfigBuilder,
@@ -40,11 +41,17 @@ use url::Url;
 
 pub const NAMESPACE: &str = "default";
 pub const TEST_Q: &str = "q";
+/// The env var used to specify where the integ tests should point
+pub const INTEG_SERVER_TARGET_ENV_VAR: &str = "TEMPORAL_SERVICE_ADDRESS";
+/// This env var is set (to any value) if temporalite is in use
+pub const INTEG_TEMPORALITE_USED_ENV_VAR: &str = "INTEG_TEMPORALITE_ON";
+/// This env var is set (to any value) if the test server is in use
+pub const INTEG_TEST_SERVER_USED_ENV_VAR: &str = "INTEG_TEST_SERVER_ON";
+
 /// 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 worker 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) -> CoreWfStarter {
@@ -433,8 +440,10 @@ impl WorkerInterceptor for TestWorkerCompletionIceptor {
     }
 }
 
+/// Returns the client options used to connect to the server used for integration tests.
 pub fn get_integ_server_options() -> ClientOptions {
-    let temporal_server_address = match env::var("TEMPORAL_SERVICE_ADDRESS") {
+    telemetry_init(&get_integ_telem_options()).expect("Telemetry inits cleanly");
+    let temporal_server_address = match env::var(INTEG_SERVER_TARGET_ENV_VAR) {
         Ok(addr) => addr,
         Err(_) => "http://localhost:7233".to_owned(),
     };
@@ -473,6 +482,16 @@ pub fn get_integ_telem_options() -> TelemetryOptions {
         .unwrap()
 }
 
+pub fn default_cached_download() -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Default {
+            sdk_name: "sdk-rust".to_string(),
+            sdk_version: "0.1.0".to_string(),
+        },
+        dest_dir: None,
+    }
+}
+
 pub fn schedule_activity_cmd(
     seq: u32,
     task_q: &str,

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

@@ -1,14 +1,11 @@
 use std::time::{SystemTime, UNIX_EPOCH};
-use temporal_client::{TestService, WorkflowService};
-use temporal_sdk_core::{
-    ephemeral_server::{
-        EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
-        TestServerConfigBuilder,
-    },
-    ClientOptions, ClientOptionsBuilder,
+use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
+use temporal_sdk_core::ephemeral_server::{
+    EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporaliteConfigBuilder,
+    TestServerConfigBuilder,
 };
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
-use temporal_sdk_core_test_utils::NAMESPACE;
+use temporal_sdk_core_test_utils::{default_cached_download, NAMESPACE};
 use url::Url;
 
 #[tokio::test]
@@ -17,8 +14,9 @@ async fn temporalite_default() {
         .exe(default_cached_download())
         .build()
         .unwrap();
-    let server = config.start_server().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
 }
 
 #[tokio::test]
@@ -27,8 +25,9 @@ async fn temporalite_fixed() {
         .exe(fixed_cached_download("v0.1.1"))
         .build()
         .unwrap();
-    let server = config.start_server().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
 }
 
 #[tokio::test]
@@ -54,8 +53,9 @@ async fn test_server_default() {
         .exe(default_cached_download())
         .build()
         .unwrap();
-    let server = config.start_server().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
 }
 
 #[tokio::test]
@@ -64,8 +64,9 @@ async fn test_server_fixed() {
         .exe(fixed_cached_download("v1.16.0"))
         .build()
         .unwrap();
-    let server = config.start_server().await.unwrap();
+    let mut server = config.start_server().await.unwrap();
     assert_ephemeral_server(&server).await;
+    server.shutdown().await.unwrap();
 }
 
 #[tokio::test]
@@ -85,9 +86,22 @@ async fn test_server_shutdown_port_reuse() {
     server.shutdown().await.unwrap();
 }
 
+fn fixed_cached_download(version: &str) -> EphemeralExe {
+    EphemeralExe::CachedDownload {
+        version: EphemeralExeVersion::Fixed(version.to_string()),
+        dest_dir: None,
+    }
+}
+
 async fn assert_ephemeral_server(server: &EphemeralServer) {
     // Connect and describe namespace
-    let mut client = client_options(&server.target)
+    let mut client = ClientOptionsBuilder::default()
+        .identity("integ_tester".to_string())
+        .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
+        .client_name("temporal-core".to_string())
+        .client_version("0.1.0".to_string())
+        .build()
+        .unwrap()
         .connect_no_namespace(None, None)
         .await
         .unwrap();
@@ -112,30 +126,3 @@ async fn assert_ephemeral_server(server: &EphemeralServer) {
         assert!(curr_seconds - 300 < resp_seconds && curr_seconds + 300 > resp_seconds);
     }
 }
-
-fn default_cached_download() -> EphemeralExe {
-    EphemeralExe::CachedDownload {
-        version: EphemeralExeVersion::Default {
-            sdk_name: "sdk-rust".to_string(),
-            sdk_version: "0.1.0".to_string(),
-        },
-        dest_dir: None,
-    }
-}
-
-fn fixed_cached_download(version: &str) -> EphemeralExe {
-    EphemeralExe::CachedDownload {
-        version: EphemeralExeVersion::Fixed(version.to_string()),
-        dest_dir: None,
-    }
-}
-
-fn client_options(target: &str) -> ClientOptions {
-    return ClientOptionsBuilder::default()
-        .identity("integ_tester".to_string())
-        .target_url(Url::try_from(&*format!("http://{}", target)).unwrap())
-        .client_name("temporal-core".to_string())
-        .client_version("0.1.0".to_string())
-        .build()
-        .unwrap();
-}

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

@@ -133,6 +133,7 @@ async fn can_paginate_long_history() {
     worker.run_until_done().await.unwrap();
 }
 
+// TODO: Takes ages now, fix somehow
 #[tokio::test]
 async fn poll_of_nonexistent_namespace_is_fatal() {
     let mut starter = CoreWfStarter::new("whatever_yo");