@temporalio/core-bridge 0.23.0 → 1.0.0

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;
@@ -69,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,

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

@@ -1,6 +1,6 @@
 use std::time::Duration;
 use temporal_sdk_core_protos::{
-    coresdk::common::RetryPolicy, temporal::api::failure::v1::ApplicationFailureInfo,
+    temporal::api::{common::v1::RetryPolicy, failure::v1::ApplicationFailureInfo},
     utilities::TryIntoOrNone,
 };
 

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 => {

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

@@ -18,9 +18,12 @@ use opentelemetry::{
 };
 use opentelemetry_otlp::WithExportConfig;
 use parking_lot::{const_mutex, Mutex};
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::{collections::VecDeque, net::SocketAddr, time::Duration};
+use std::{
+    collections::{HashMap, VecDeque},
+    convert::TryInto,
+    net::SocketAddr,
+    time::Duration,
+};
 use temporal_sdk_core_api::CoreTelemetry;
 use tonic::metadata::MetadataMap;
 use tracing_subscriber::{filter::ParseError, layer::SubscriberExt, EnvFilter};
@@ -93,6 +96,11 @@ pub struct TelemetryOptions {
     /// Optional metrics exporter - set as None to disable.
     #[builder(setter(into, strip_option), default)]
     pub metrics: Option<MetricsExporter>,
+
+    /// If set true, do not prefix metrics with `temporal_`. Will be removed eventually as
+    /// the prefix is consistent with other SDKs.
+    #[builder(default)]
+    pub no_temporal_prefix_for_metrics: bool,
 }
 
 impl TelemetryOptions {
@@ -119,6 +127,7 @@ pub struct GlobalTelemDat {
     core_export_logger: Option<CoreExportLogger>,
     runtime: Option<tokio::runtime::Runtime>,
     prom_srv: Option<PromServer>,
+    no_temporal_prefix_for_metrics: bool,
 }
 
 impl GlobalTelemDat {
@@ -179,7 +188,10 @@ pub fn telemetry_init(opts: &TelemetryOptions) -> Result<&'static GlobalTelemDat
                 .worker_threads(2)
                 .enable_all()
                 .build()?;
-            let mut globaldat = GlobalTelemDat::default();
+            let mut globaldat = GlobalTelemDat {
+                no_temporal_prefix_for_metrics: opts.no_temporal_prefix_for_metrics,
+                ..Default::default()
+            };
 
             if let Some(ref logger) = opts.logging {
                 match logger {
@@ -318,6 +330,7 @@ pub(crate) fn test_telem_console() {
         logging: Some(Logger::Console),
         tracing: None,
         metrics: None,
+        no_temporal_prefix_for_metrics: false,
     })
     .unwrap();
 }
@@ -333,6 +346,7 @@ pub(crate) fn test_telem_collector() {
             headers: Default::default(),
         })),
         metrics: None,
+        no_temporal_prefix_for_metrics: false,
     })
     .unwrap();
 }