@temporalio/core-bridge 0.22.0 → 1.0.0-rc.1

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

@@ -9,17 +9,16 @@
 pub extern crate assert_matches;
 #[macro_use]
 extern crate tracing;
+extern crate core;
 
 mod abstractions;
 mod log_export;
-mod pending_activations;
 mod pollers;
 mod protosext;
 pub mod replay;
 pub(crate) mod retry_logic;
 pub(crate) mod telemetry;
 mod worker;
-mod workflow;
 
 #[cfg(test)]
 mod core_tests;
@@ -34,7 +33,8 @@ pub use pollers::{
     TlsConfig, WorkflowClientTrait,
 };
 pub use telemetry::{
-    fetch_global_buffered_logs, telemetry_init, TelemetryOptions, TelemetryOptionsBuilder,
+    fetch_global_buffered_logs, telemetry_init, Logger, MetricsExporter, OtelCollectorOptions,
+    TelemetryOptions, TelemetryOptionsBuilder, TraceExporter,
 };
 pub use temporal_sdk_core_api as api;
 pub use temporal_sdk_core_protos as protos;
@@ -68,11 +68,14 @@ where
     CT: Into<AnyClient>,
 {
     let as_enum = client.into();
-    // TODO: Assert namespaces match
     let client = match as_enum {
         AnyClient::HighLevel(ac) => ac,
         AnyClient::LowLevel(ll) => {
-            let client = Client::new(*ll, worker_config.namespace.clone());
+            let mut client = Client::new(*ll, worker_config.namespace.clone());
+            client.set_worker_build_id(worker_config.worker_build_id.clone());
+            if let Some(ref id_override) = worker_config.client_identity_override {
+                client.options_mut().identity = id_override.clone();
+            }
             let retry_client = RetryClient::new(client, RetryConfig::default());
             Arc::new(retry_client)
         }

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

@@ -17,14 +17,15 @@ use temporal_sdk_core_protos::temporal::api::workflowservice::v1::{
 use tokio::{
     sync::{
         mpsc::{channel, Receiver},
-        watch, Mutex, Semaphore,
+        Mutex, Semaphore,
     },
     task::JoinHandle,
 };
+use tokio_util::sync::CancellationToken;
 
 pub struct LongPollBuffer<T> {
     buffered_polls: Mutex<Receiver<pollers::Result<T>>>,
-    shutdown: watch::Sender<bool>,
+    shutdown: CancellationToken,
     /// This semaphore exists to ensure that we only poll server as many times as core actually
     /// *asked* it to be polled - otherwise we might spin and buffer polls constantly. This also
     /// means unit tests can continue to function in a predictable manner when calling mocks.
@@ -56,6 +57,7 @@ where
         poll_fn: impl Fn() -> FT + Send + Sync + 'static,
         max_pollers: usize,
         buffer_size: usize,
+        shutdown: CancellationToken,
     ) -> Self
     where
         FT: Future<Output = pollers::Result<T>> + Send,
@@ -63,28 +65,27 @@ where
         let (tx, rx) = channel(buffer_size);
         let polls_requested = Arc::new(Semaphore::new(0));
         let active_pollers = Arc::new(AtomicUsize::new(0));
-        let (shutdown_tx, shutdown_rx) = watch::channel(false);
         let join_handles = FuturesUnordered::new();
         let pf = Arc::new(poll_fn);
         for _ in 0..max_pollers {
             let tx = tx.clone();
             let pf = pf.clone();
-            let mut shutdown = shutdown_rx.clone();
+            let shutdown = shutdown.clone();
             let polls_requested = polls_requested.clone();
             let ap = active_pollers.clone();
             let jh = tokio::spawn(async move {
                 loop {
-                    if *shutdown.borrow() {
+                    if shutdown.is_cancelled() {
                         break;
                     }
                     let sp = tokio::select! {
                         sp = polls_requested.acquire() => sp.expect("Polls semaphore not dropped"),
-                        _ = shutdown.changed() => continue,
+                        _ = shutdown.cancelled() => continue,
                     };
                     let _active_guard = ActiveCounter::new(ap.as_ref());
                     let r = tokio::select! {
                         r = pf() => r,
-                        _ = shutdown.changed() => continue,
+                        _ = shutdown.cancelled() => continue,
                     };
                     sp.forget();
                     let _ = tx.send(r).await;
@@ -94,7 +95,7 @@ where
         }
         Self {
             buffered_polls: Mutex::new(rx),
-            shutdown: shutdown_tx,
+            shutdown,
             polls_requested,
             join_handles,
             num_pollers_changed: None,
@@ -142,11 +143,11 @@ where
     }
 
     fn notify_shutdown(&self) {
-        let _ = self.shutdown.send(true);
+        self.shutdown.cancel();
     }
 
     async fn shutdown(mut self) {
-        let _ = self.shutdown.send(true);
+        self.notify_shutdown();
         while self.join_handles.next().await.is_some() {}
     }
 
@@ -203,6 +204,7 @@ pub(crate) fn new_workflow_task_buffer(
     is_sticky: bool,
     concurrent_pollers: usize,
     buffer_size: usize,
+    shutdown: CancellationToken,
 ) -> PollWorkflowTaskBuffer {
     LongPollBuffer::new(
         move || {
@@ -212,6 +214,7 @@ pub(crate) fn new_workflow_task_buffer(
         },
         concurrent_pollers,
         buffer_size,
+        shutdown,
     )
 }
 
@@ -222,6 +225,7 @@ pub(crate) fn new_activity_task_buffer(
     concurrent_pollers: usize,
     buffer_size: usize,
     max_tps: Option<f64>,
+    shutdown: CancellationToken,
 ) -> PollActivityTaskBuffer {
     LongPollBuffer::new(
         move || {
@@ -231,6 +235,7 @@ pub(crate) fn new_activity_task_buffer(
         },
         concurrent_pollers,
         buffer_size,
+        shutdown,
     )
 }
 
@@ -262,6 +267,7 @@ mod tests {
             false,
             1,
             1,
+            CancellationToken::new(),
         );
 
         // Poll a bunch of times, "interrupting" it each time, we should only actually have polled

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

@@ -1,6 +1,6 @@
 use crate::{
-    worker::LocalActivityExecutionResult, workflow::LEGACY_QUERY_ID, CompleteActivityError,
-    TaskToken,
+    worker::{LocalActivityExecutionResult, LEGACY_QUERY_ID},
+    CompleteActivityError, TaskToken,
 };
 use anyhow::anyhow;
 use std::{
@@ -15,7 +15,7 @@ use temporal_sdk_core_protos::{
         activity_result::{activity_execution_result, activity_execution_result::Status},
         common::{
             decode_change_marker_details, extract_local_activity_marker_data,
-            extract_local_activity_marker_details, Payload as SDKPayload, RetryPolicy,
+            extract_local_activity_marker_details,
         },
         external_data::LocalActivityMarkerData,
         workflow_activation::{
@@ -28,7 +28,7 @@ use temporal_sdk_core_protos::{
         workflow_completion,
     },
     temporal::api::{
-        common::v1::{Payload, WorkflowExecution},
+        common::v1::{Payload, RetryPolicy, WorkflowExecution},
         enums::v1::EventType,
         failure::v1::Failure,
         history::v1::{history_event, History, HistoryEvent, MarkerRecordedEventAttributes},
@@ -264,8 +264,8 @@ pub struct ValidScheduleLA {
     pub activity_type: String,
     pub attempt: u32,
     pub original_schedule_time: Option<SystemTime>,
-    pub headers: HashMap<String, SDKPayload>,
-    pub arguments: Vec<SDKPayload>,
+    pub headers: HashMap<String, Payload>,
+    pub arguments: Vec<Payload>,
     pub schedule_to_start_timeout: Option<Duration>,
     pub close_timeouts: LACloseTimeouts,
     pub retry_policy: RetryPolicy,
@@ -359,9 +359,7 @@ impl ValidScheduleLA {
                 ))
             }
         };
-        let retry_policy = v
-            .retry_policy
-            .ok_or_else(|| anyhow!("Retry policy must be defined!"))?;
+        let retry_policy = v.retry_policy.unwrap_or_default();
         let local_retry_threshold = v
             .local_retry_threshold
             .clone()

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

@@ -1,5 +1,8 @@
 use std::time::Duration;
-use temporal_sdk_core_protos::{coresdk::common::RetryPolicy, utilities::TryIntoOrNone};
+use temporal_sdk_core_protos::{
+    temporal::api::{common::v1::RetryPolicy, failure::v1::ApplicationFailureInfo},
+    utilities::TryIntoOrNone,
+};
 
 pub(crate) trait RetryPolicyExt {
     /// Ask this retry policy if a retry should be performed. Caller provides the current attempt
@@ -7,11 +10,31 @@ pub(crate) trait RetryPolicyExt {
     ///
     /// Returns `None` if it should not, otherwise a duration indicating how long to wait before
     /// performing the retry.
-    fn should_retry(&self, attempt_number: usize, err_type_str: &str) -> Option<Duration>;
+    ///
+    /// Applies defaults to missing fields:
+    /// `initial_interval` - 1 second
+    /// `maximum_interval` - 100 x initial_interval
+    /// `backoff_coefficient` - 2.0
+    fn should_retry(
+        &self,
+        attempt_number: usize,
+        application_failure: Option<&ApplicationFailureInfo>,
+    ) -> Option<Duration>;
 }
 
 impl RetryPolicyExt for RetryPolicy {
-    fn should_retry(&self, attempt_number: usize, err_type_str: &str) -> Option<Duration> {
+    fn should_retry(
+        &self,
+        attempt_number: usize,
+        application_failure: Option<&ApplicationFailureInfo>,
+    ) -> Option<Duration> {
+        let non_retryable = application_failure
+            .map(|f| f.non_retryable)
+            .unwrap_or_default();
+        if non_retryable {
+            return None;
+        }
+        let err_type_str = application_failure.map_or("", |f| &f.r#type);
         let realmax = self.maximum_attempts.max(0);
         if realmax > 0 && attempt_number >= realmax as usize {
             return None;
@@ -23,7 +46,11 @@ impl RetryPolicyExt for RetryPolicy {
             }
         }
 
-        let converted_interval = self.initial_interval.clone().try_into_or_none();
+        let converted_interval = self
+            .initial_interval
+            .clone()
+            .try_into_or_none()
+            .or(Some(Duration::from_secs(1)));
         if attempt_number == 1 {
             return converted_interval;
         }
@@ -74,32 +101,32 @@ mod tests {
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };
-        let res = rp.should_retry(1, "").unwrap();
+        let res = rp.should_retry(1, None).unwrap();
         assert_eq!(res.as_millis(), 1_000);
-        let res = rp.should_retry(2, "").unwrap();
+        let res = rp.should_retry(2, None).unwrap();
         assert_eq!(res.as_millis(), 2_000);
-        let res = rp.should_retry(3, "").unwrap();
+        let res = rp.should_retry(3, None).unwrap();
         assert_eq!(res.as_millis(), 4_000);
-        let res = rp.should_retry(4, "").unwrap();
+        let res = rp.should_retry(4, None).unwrap();
         assert_eq!(res.as_millis(), 8_000);
-        let res = rp.should_retry(5, "").unwrap();
+        let res = rp.should_retry(5, None).unwrap();
         assert_eq!(res.as_millis(), 10_000);
-        let res = rp.should_retry(6, "").unwrap();
+        let res = rp.should_retry(6, None).unwrap();
         assert_eq!(res.as_millis(), 10_000);
         // Max attempts - no retry
-        assert!(rp.should_retry(10, "").is_none());
+        assert!(rp.should_retry(10, None).is_none());
     }
 
     #[test]
     fn no_interval_no_backoff() {
         let rp = RetryPolicy {
             initial_interval: None,
-            backoff_coefficient: 2.0,
+            backoff_coefficient: 0.,
             maximum_interval: None,
             maximum_attempts: 10,
             non_retryable_error_types: vec![],
         };
-        assert!(rp.should_retry(1, "").is_none());
+        assert!(rp.should_retry(1, None).is_some());
     }
 
     #[test]
@@ -112,7 +139,7 @@ mod tests {
             non_retryable_error_types: vec![],
         };
         for i in 0..50 {
-            assert!(rp.should_retry(i, "").is_some());
+            assert!(rp.should_retry(i, None).is_some());
         }
     }
 
@@ -126,7 +153,7 @@ mod tests {
             non_retryable_error_types: vec![],
         };
         for i in 0..50 {
-            assert!(rp.should_retry(i, "").is_some());
+            assert!(rp.should_retry(i, None).is_some());
         }
     }
 
@@ -139,6 +166,36 @@ mod tests {
             maximum_attempts: 10,
             non_retryable_error_types: vec!["no retry".to_string()],
         };
-        assert!(rp.should_retry(1, "no retry").is_none());
+        assert!(rp
+            .should_retry(
+                1,
+                Some(&ApplicationFailureInfo {
+                    r#type: "no retry".to_string(),
+                    non_retryable: false,
+                    details: None,
+                })
+            )
+            .is_none());
+    }
+
+    #[test]
+    fn no_non_retryable_application_failure() {
+        let rp = RetryPolicy {
+            initial_interval: Some(Duration::from_secs(1).into()),
+            backoff_coefficient: 2.0,
+            maximum_interval: Some(Duration::from_secs(10).into()),
+            maximum_attempts: 10,
+            non_retryable_error_types: vec![],
+        };
+        assert!(rp
+            .should_retry(
+                1,
+                Some(&ApplicationFailureInfo {
+                    r#type: "".to_string(),
+                    non_retryable: true,
+                    details: None,
+                })
+            )
+            .is_none());
     }
 }

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

@@ -1,4 +1,5 @@
 use super::TELEM_SERVICE_NAME;
+use crate::telemetry::GLOBAL_TELEM_DAT;
 use opentelemetry::{
     global,
     metrics::{Counter, Descriptor, InstrumentKind, Meter, ValueRecorder},
@@ -16,9 +17,6 @@ use std::{borrow::Cow, sync::Arc, time::Duration};
 /// appropriate k/vs have already been set.
 #[derive(Default, Clone, Debug)]
 pub(crate) struct MetricsContext {
-    // TODO: Ideally this would hold bound metrics, but using them is basically impossible because
-    //   of lifetime issues: https://github.com/open-telemetry/opentelemetry-rust/issues/629
-    //   Use once fixed.
     kvs: Arc<Vec<KeyValue>>,
 }
 
@@ -159,6 +157,18 @@ lazy_static::lazy_static! {
         global::meter(TELEM_SERVICE_NAME)
     };
 }
+fn metric_prefix() -> &'static str {
+    GLOBAL_TELEM_DAT
+        .get()
+        .map(|gtd| {
+            if gtd.no_temporal_prefix_for_metrics {
+                ""
+            } else {
+                "temporal_"
+            }
+        })
+        .unwrap_or("")
+}
 
 /// Define a temporal metric. All metrics are kept private to this file, and should be accessed
 /// through functions on the [MetricsContext]
@@ -166,14 +176,14 @@ macro_rules! tm {
     (ctr, $ident:ident, $name:expr) => {
         lazy_static::lazy_static! {
             static ref $ident: Counter<u64> = {
-                METRIC_METER.u64_counter($name).init()
+                METRIC_METER.u64_counter(metric_prefix().to_string() + $name).init()
             };
         }
     };
     (vr_u64, $ident:ident, $name:expr) => {
         lazy_static::lazy_static! {
             static ref $ident: ValueRecorder<u64> = {
-                METRIC_METER.u64_value_recorder($name).init()
+                METRIC_METER.u64_value_recorder(metric_prefix().to_string() + $name).init()
             };
         }
     };
@@ -334,8 +344,12 @@ impl AggregatorSelector for SDKAggSelector {
         }
 
         if *descriptor.instrument_kind() == InstrumentKind::ValueRecorder {
+            let dname = descriptor
+                .name()
+                .strip_prefix(metric_prefix())
+                .unwrap_or_else(|| descriptor.name());
             // Some recorders are just gauges
-            match descriptor.name() {
+            match dname {
                 STICKY_CACHE_SIZE_NAME | NUM_POLLERS_NAME | TASK_SLOTS_AVAILABLE_NAME => {
                     return Some(Arc::new(last_value()))
                 }
@@ -343,7 +357,7 @@ impl AggregatorSelector for SDKAggSelector {
             }
 
             // Other recorders will select their appropriate buckets
-            let buckets = match descriptor.name() {
+            let buckets = match dname {
                 WF_E2E_LATENCY_NAME => WF_LATENCY_MS_BUCKETS,
                 WF_TASK_EXECUTION_LATENCY_NAME | WF_TASK_REPLAY_LATENCY_NAME => WF_TASK_MS_BUCKETS,
                 WF_TASK_SCHED_TO_START_LATENCY_NAME | ACT_SCHED_TO_START_LATENCY_NAME => {