@temporalio/core-bridge 1.1.0 → 1.3.1

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

@@ -81,7 +81,7 @@ const NANOS_PER_SEC: u32 = 1_000_000_000;
 fn try_from_secs_f64(secs: f64) -> Option<Duration> {
     const MAX_NANOS_F64: f64 = ((u64::MAX as u128 + 1) * (NANOS_PER_SEC as u128)) as f64;
     let nanos = secs * (NANOS_PER_SEC as f64);
-    if !nanos.is_finite() || nanos >= MAX_NANOS_F64 || nanos < 0.0 {
+    if !nanos.is_finite() || !(0.0..MAX_NANOS_F64).contains(&nanos) {
         None
     } else {
         Some(Duration::from_secs_f64(secs))
@@ -91,13 +91,14 @@ fn try_from_secs_f64(secs: f64) -> Option<Duration> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::prost_dur;
 
     #[test]
     fn calcs_backoffs_properly() {
         let rp = RetryPolicy {
-            initial_interval: Some(Duration::from_secs(1).into()),
+            initial_interval: Some(prost_dur!(from_secs(1))),
             backoff_coefficient: 2.0,
-            maximum_interval: Some(Duration::from_secs(10).into()),
+            maximum_interval: Some(prost_dur!(from_secs(10))),
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };
@@ -132,7 +133,7 @@ mod tests {
     #[test]
     fn max_attempts_zero_retry_forever() {
         let rp = RetryPolicy {
-            initial_interval: Some(Duration::from_secs(1).into()),
+            initial_interval: Some(prost_dur!(from_secs(1))),
             backoff_coefficient: 1.2,
             maximum_interval: None,
             maximum_attempts: 0,
@@ -146,7 +147,7 @@ mod tests {
     #[test]
     fn no_overflows() {
         let rp = RetryPolicy {
-            initial_interval: Some(Duration::from_secs(1).into()),
+            initial_interval: Some(prost_dur!(from_secs(1))),
             backoff_coefficient: 10.,
             maximum_interval: None,
             maximum_attempts: 0,
@@ -160,9 +161,9 @@ mod tests {
     #[test]
     fn no_retry_err_str_match() {
         let rp = RetryPolicy {
-            initial_interval: Some(Duration::from_secs(1).into()),
+            initial_interval: Some(prost_dur!(from_secs(1))),
             backoff_coefficient: 2.0,
-            maximum_interval: Some(Duration::from_secs(10).into()),
+            maximum_interval: Some(prost_dur!(from_secs(10))),
             maximum_attempts: 10,
             non_retryable_error_types: vec!["no retry".to_string()],
         };
@@ -181,9 +182,9 @@ mod tests {
     #[test]
     fn no_non_retryable_application_failure() {
         let rp = RetryPolicy {
-            initial_interval: Some(Duration::from_secs(1).into()),
+            initial_interval: Some(prost_dur!(from_secs(1))),
             backoff_coefficient: 2.0,
-            maximum_interval: Some(Duration::from_secs(10).into()),
+            maximum_interval: Some(prost_dur!(from_secs(10))),
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };

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

@@ -25,7 +25,6 @@ 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;
 
@@ -237,9 +236,11 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
                                     opentelemetry_otlp::new_exporter()
                                         .tonic()
                                         .with_endpoint(url.to_string())
-                                        .with_metadata(MetadataMap::from_headers(
-                                            headers.try_into()?,
-                                        )),
+                                        .with_metadata(
+                                            tonic_otel::metadata::MetadataMap::from_headers(
+                                                headers.try_into()?,
+                                            ),
+                                        ),
                                 )
                                 .build()?;
                             global::set_meter_provider(metrics.provider());
@@ -261,9 +262,11 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
                                     opentelemetry_otlp::new_exporter()
                                         .tonic()
                                         .with_endpoint(url.to_string())
-                                        .with_metadata(MetadataMap::from_headers(
-                                            headers.try_into()?,
-                                        )),
+                                        .with_metadata(
+                                            tonic_otel::metadata::MetadataMap::from_headers(
+                                                headers.try_into()?,
+                                            ),
+                                        ),
                                 )
                                 .with_trace_config(tracer_cfg)
                                 .install_batch(opentelemetry::runtime::Tokio)?;

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

@@ -9,7 +9,7 @@ use crate::{
         client::{mocks::mock_workflow_client, MockWorkerClient, WorkerClient},
         new_wft_poller,
     },
-    TaskToken, Worker, WorkerClientBag, WorkerConfig, WorkerConfigBuilder,
+    TaskToken, Worker, WorkerConfig, WorkerConfigBuilder,
 };
 use bimap::BiMap;
 use futures::{future::BoxFuture, stream, stream::BoxStream, FutureExt, Stream, StreamExt};
@@ -136,7 +136,7 @@ pub(crate) fn mock_worker(mocks: MocksHolder) -> Worker {
     Worker::new_with_pollers(
         mocks.inputs.config,
         sticky_q,
-        Arc::new(mocks.client_bag),
+        mocks.client,
         mocks.inputs.wft_stream,
         mocks.inputs.act_poller,
         Default::default(),
@@ -166,7 +166,7 @@ pub struct FakeWfResponses {
 
 // TODO: Should be all-internal to this module
 pub struct MocksHolder {
-    client_bag: WorkerClientBag,
+    client: Arc<dyn WorkerClient>,
     inputs: MockWorkerInputs,
     pub outstanding_task_map: Option<OutstandingWFTMap>,
 }
@@ -218,11 +218,11 @@ impl MockWorkerInputs {
 
 impl MocksHolder {
     pub(crate) fn from_mock_worker(
-        client_bag: WorkerClientBag,
+        client: impl WorkerClient + 'static,
         mock_worker: MockWorkerInputs,
     ) -> Self {
         Self {
-            client_bag,
+            client: Arc::new(client),
             inputs: mock_worker,
             outstanding_task_map: None,
         }
@@ -245,7 +245,7 @@ impl MocksHolder {
             config: test_worker_cfg().build().unwrap(),
         };
         Self {
-            client_bag: client.into(),
+            client: Arc::new(client),
             inputs: mock_worker,
             outstanding_task_map: None,
         }
@@ -267,7 +267,7 @@ impl MocksHolder {
             config: test_worker_cfg().build().unwrap(),
         };
         Self {
-            client_bag: client.into(),
+            client: Arc::new(client),
             inputs: mock_worker,
             outstanding_task_map: None,
         }
@@ -356,6 +356,7 @@ pub(crate) fn single_hist_mock_sg(
     build_mock_pollers(mh)
 }
 
+#[allow(clippy::type_complexity)]
 pub(crate) struct MockPollCfg {
     pub hists: Vec<FakeWfResponses>,
     pub enforce_correct_number_of_polls: bool,
@@ -604,7 +605,7 @@ pub(crate) fn build_mock_pollers(mut cfg: MockPollCfg) -> MocksHolder {
         });
 
     MocksHolder {
-        client_bag: cfg.mock_client.into(),
+        client: Arc::new(cfg.mock_client),
         inputs: mock_worker,
         outstanding_task_map: Some(outstanding_wf_task_tokens),
     }
@@ -863,3 +864,12 @@ macro_rules! advance_fut {
         }
     };
 }
+
+#[macro_export]
+macro_rules! prost_dur {
+    ($dur_call:ident $args:tt) => {
+        std::time::Duration::$dur_call$args
+            .try_into()
+            .expect("test duration fits")
+    };
+}

package/sdk-core/core/src/worker/activities/activity_heartbeat_manager.rs

@@ -1,5 +1,5 @@
 use crate::{
-    worker::{activities::PendingActivityCancel, client::WorkerClientBag},
+    worker::{activities::PendingActivityCancel, client::WorkerClient},
     TaskToken,
 };
 use futures::StreamExt;
@@ -304,7 +304,7 @@ impl HeartbeatStreamState {
 impl ActivityHeartbeatManager {
     /// Creates a new instance of an activity heartbeat manager and returns a handle to the user,
     /// which allows to send new heartbeats and initiate the shutdown.
-    pub fn new(client: Arc<WorkerClientBag>) -> Self {
+    pub fn new(client: Arc<dyn WorkerClient>) -> Self {
         let (heartbeat_stream_state, heartbeat_tx_source, shutdown_token) =
             HeartbeatStreamState::new();
         let (cancels_tx, cancels_rx) = unbounded_channel();
@@ -425,7 +425,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         // Send 2 heartbeat requests for 20ms apart.
         // The first heartbeat should be sent right away, and
@@ -446,9 +446,9 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(3);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
-        // Heartbeats always get sent if recorded less frequently than the throttle intreval
+        // Heartbeats always get sent if recorded less frequently than the throttle interval
         for i in 0_u8..3 {
             record_heartbeat(&hm, fake_task_token.clone(), i, Duration::from_millis(10));
             sleep(Duration::from_millis(20)).await;
@@ -466,7 +466,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(1);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         // Send a whole bunch of heartbeats very fast. We should still only send one total.
         for i in 0_u8..50 {
@@ -485,7 +485,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         sleep(Duration::from_millis(500)).await;
@@ -502,7 +502,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(2);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         // Let it propagate
@@ -522,7 +522,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(1);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         let fake_task_token = vec![1, 2, 3];
         record_heartbeat(&hm, fake_task_token.clone(), 0, Duration::from_millis(100));
         hm.evict(fake_task_token.clone().into()).await;
@@ -537,7 +537,7 @@ mod test {
             .expect_record_activity_heartbeat()
             .returning(|_, _| Ok(RecordActivityTaskHeartbeatResponse::default()))
             .times(0);
-        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client.into()));
+        let hm = ActivityHeartbeatManager::new(Arc::new(mock_client));
         hm.shutdown().await;
         match hm.record(
             ActivityHeartbeat {

package/sdk-core/core/src/worker/activities/local_activities.rs

@@ -389,8 +389,8 @@ impl LocalActivityManager {
                 current_attempt_scheduled_time: Some(new_la.schedule_time.into()),
                 started_time: Some(SystemTime::now().into()),
                 attempt,
-                schedule_to_close_timeout: schedule_to_close.map(Into::into),
-                start_to_close_timeout: start_to_close.map(Into::into),
+                schedule_to_close_timeout: schedule_to_close.and_then(|d| d.try_into().ok()),
+                start_to_close_timeout: start_to_close.and_then(|d| d.try_into().ok()),
                 heartbeat_timeout: None,
                 retry_policy: Some(sa.retry_policy),
                 is_local: true,
@@ -440,7 +440,7 @@ impl LocalActivityManager {
                             // We want this to be reported, as the workflow will mark this
                             // failure down, then start a timer for backoff.
                             return LACompleteAction::LangDoesTimerBackoff(
-                                backoff_dur.into(),
+                                backoff_dur.try_into().expect("backoff fits into proto"),
                                 info,
                             );
                         }
@@ -638,7 +638,7 @@ impl Drop for TimeoutBag {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::protosext::LACloseTimeouts;
+    use crate::{prost_dur, protosext::LACloseTimeouts};
     use temporal_sdk_core_protos::temporal::api::{
         common::v1::RetryPolicy,
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
@@ -764,9 +764,9 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(1).into()),
+                    initial_interval: Some(prost_dur!(from_secs(1))),
                     backoff_coefficient: 10.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec![],
                 },
@@ -799,9 +799,9 @@ mod tests {
                 activity_id: "1".to_string(),
                 attempt: 1,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(1).into()),
+                    initial_interval: Some(prost_dur!(from_secs(1))),
                     backoff_coefficient: 10.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec!["TestError".to_string()],
                 },
@@ -843,9 +843,9 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_secs(10).into()),
+                    initial_interval: Some(prost_dur!(from_secs(10))),
                     backoff_coefficient: 1.0,
-                    maximum_interval: Some(Duration::from_secs(10).into()),
+                    maximum_interval: Some(prost_dur!(from_secs(10))),
                     maximum_attempts: 10,
                     non_retryable_error_types: vec![],
                 },
@@ -892,7 +892,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },
@@ -929,7 +929,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },
@@ -975,7 +975,7 @@ mod tests {
                 activity_id: 1.to_string(),
                 attempt: 5,
                 retry_policy: RetryPolicy {
-                    initial_interval: Some(Duration::from_millis(10).into()),
+                    initial_interval: Some(prost_dur!(from_millis(10))),
                     backoff_coefficient: 1.0,
                     ..Default::default()
                 },

package/sdk-core/core/src/worker/activities.rs

@@ -12,10 +12,9 @@ use crate::{
     pollers::BoxedActPoller,
     telemetry::metrics::{activity_type, activity_worker_type, workflow_type, MetricsContext},
     worker::{
-        activities::activity_heartbeat_manager::ActivityHeartbeatError,
-        client::{WorkerClient, WorkerClientBag},
+        activities::activity_heartbeat_manager::ActivityHeartbeatError, client::WorkerClient,
     },
-    CompleteActivityError, PollActivityError, TaskToken,
+    PollActivityError, TaskToken,
 };
 use activity_heartbeat_manager::ActivityHeartbeatManager;
 use dashmap::DashMap;
@@ -136,7 +135,7 @@ impl WorkerActivityTasks {
         max_activity_tasks: usize,
         max_worker_act_per_sec: Option<f64>,
         poller: BoxedActPoller,
-        client: Arc<WorkerClientBag>,
+        client: Arc<dyn WorkerClient>,
         metrics: MetricsContext,
         max_heartbeat_throttle_interval: Duration,
         default_heartbeat_throttle_interval: Duration,
@@ -232,7 +231,7 @@ impl WorkerActivityTasks {
         task_token: TaskToken,
         status: aer::Status,
         client: &dyn WorkerClient,
-    ) -> Result<(), CompleteActivityError> {
+    ) {
         if let Some((_, act_info)) = self.outstanding_activity_tasks.remove(&task_token) {
             let act_metrics = self.metrics.with_new_attrs([
                 activity_type(act_info.base.activity_type.clone()),
@@ -285,7 +284,7 @@ impl WorkerActivityTasks {
                         completion. This may happen if the activity has already been cancelled but \
                         completed anyway.");
                     } else {
-                        return Err(e.into());
+                        warn!(error=?e, "Network error while completing activity");
                     };
                 };
             };
@@ -295,7 +294,6 @@ impl WorkerActivityTasks {
                 &task_token
             );
         }
-        Ok(())
     }
 
     /// Attempt to record an activity heartbeat
@@ -446,15 +444,11 @@ mod tests {
             }
             .into(),
         ]);
-        let client = WorkerClientBag::new(
-            Box::new(mock_manual_workflow_client()),
-            "fake_namespace".to_string(),
-        );
         let atm = WorkerActivityTasks::new(
             10,
             Some(2.0),
             poller,
-            Arc::new(client),
+            Arc::new(mock_manual_workflow_client()),
             MetricsContext::default(),
             Duration::from_secs(1),
             Duration::from_secs(1),