@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -1,5 +1,5 @@
 use crate::{
-    abstractions::{dbg_panic, MeteredSemaphore, OwnedMeteredSemPermit},
+    abstractions::{dbg_panic, MeteredPermitDealer, OwnedMeteredSemPermit},
     pollers::{self, Poller},
     worker::client::WorkerClient,
 };
@@ -15,6 +15,7 @@ use std::{
     },
     time::Duration,
 };
+use temporal_sdk_core_api::worker::{ActivitySlotKind, SlotKind, WorkflowSlotKind};
 use temporal_sdk_core_protos::temporal::api::{
     taskqueue::v1::TaskQueue,
     workflowservice::v1::{PollActivityTaskQueueResponse, PollWorkflowTaskQueueResponse},
@@ -29,8 +30,10 @@ use tokio::{
 };
 use tokio_util::sync::CancellationToken;
 
-pub struct LongPollBuffer<T> {
-    buffered_polls: Mutex<UnboundedReceiver<pollers::Result<(T, OwnedMeteredSemPermit)>>>,
+type PollReceiver<T, SK> =
+    Mutex<UnboundedReceiver<pollers::Result<(T, OwnedMeteredSemPermit<SK>)>>>;
+pub(crate) struct LongPollBuffer<T, SK: SlotKind> {
+    buffered_polls: PollReceiver<T, SK>,
     shutdown: CancellationToken,
     join_handles: FuturesUnordered<JoinHandle<()>>,
     /// Pollers won't actually start polling until initialized & value is sent
@@ -63,13 +66,14 @@ where
     }
 }
 
-impl<T> LongPollBuffer<T>
+impl<T, SK> LongPollBuffer<T, SK>
 where
     T: Send + Debug + 'static,
+    SK: SlotKind + 'static,
 {
     pub(crate) fn new<FT, DelayFut>(
         poll_fn: impl Fn() -> FT + Send + Sync + 'static,
-        poll_semaphore: Arc<MeteredSemaphore>,
+        permit_dealer: Arc<MeteredPermitDealer<SK>>,
         max_pollers: usize,
         shutdown: CancellationToken,
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
@@ -91,7 +95,7 @@ where
             let pf = pf.clone();
             let shutdown = shutdown.clone();
             let ap = active_pollers.clone();
-            let poll_semaphore = poll_semaphore.clone();
+            let permit_dealer = permit_dealer.clone();
             let nph = nph.clone();
             let pre_permit_delay = pre_permit_delay.clone();
             let mut wait_for_start = wait_for_start.resubscribe();
@@ -114,7 +118,7 @@ where
                         }
                     }
                     let permit = tokio::select! {
-                        p = poll_semaphore.acquire_owned() => p,
+                        p = permit_dealer.acquire_owned() => p,
                         _ = shutdown.cancelled() => break,
                     };
                     let permit = if let Ok(p) = permit {
@@ -143,15 +147,16 @@ where
 }
 
 #[async_trait::async_trait]
-impl<T> Poller<(T, OwnedMeteredSemPermit)> for LongPollBuffer<T>
+impl<T, SK> Poller<(T, OwnedMeteredSemPermit<SK>)> for LongPollBuffer<T, SK>
 where
     T: Send + Sync + Debug + 'static,
+    SK: SlotKind + 'static,
 {
     /// Poll for the next item from this poller
     ///
     /// Returns `None` if the poller has been shut down
     #[instrument(name = "long_poll", level = "trace", skip(self))]
-    async fn poll(&self) -> Option<pollers::Result<(T, OwnedMeteredSemPermit)>> {
+    async fn poll(&self) -> Option<pollers::Result<(T, OwnedMeteredSemPermit<SK>)>> {
         if !self.did_start.fetch_or(true, Ordering::Relaxed) {
             let _ = self.starter.send(());
         }
@@ -168,8 +173,12 @@ where
         self.notify_shutdown();
         while let Some(jh) = self.join_handles.next().await {
             if let Err(e) = jh {
-                if !e.is_cancelled() {
-                    dbg_panic!("Poller task did not terminate cleanly: {:?}", e);
+                if e.is_panic() {
+                    let as_panic = e.into_panic().downcast::<String>();
+                    dbg_panic!(
+                        "Poller task died or did not terminate cleanly: {:?}",
+                        as_panic
+                    );
                 }
             }
         }
@@ -183,16 +192,26 @@ where
 
 /// A poller capable of polling on a sticky and a nonsticky queue simultaneously for workflow tasks.
 #[derive(derive_more::Constructor)]
-pub struct WorkflowTaskPoller {
+pub(crate) struct WorkflowTaskPoller {
     normal_poller: PollWorkflowTaskBuffer,
     sticky_poller: Option<PollWorkflowTaskBuffer>,
 }
 
 #[async_trait::async_trait]
-impl Poller<(PollWorkflowTaskQueueResponse, OwnedMeteredSemPermit)> for WorkflowTaskPoller {
+impl
+    Poller<(
+        PollWorkflowTaskQueueResponse,
+        OwnedMeteredSemPermit<WorkflowSlotKind>,
+    )> for WorkflowTaskPoller
+{
     async fn poll(
         &self,
-    ) -> Option<pollers::Result<(PollWorkflowTaskQueueResponse, OwnedMeteredSemPermit)>> {
+    ) -> Option<
+        pollers::Result<(
+            PollWorkflowTaskQueueResponse,
+            OwnedMeteredSemPermit<WorkflowSlotKind>,
+        )>,
+    > {
         if let Some(sq) = self.sticky_poller.as_ref() {
             tokio::select! {
                 r = self.normal_poller.poll() => r,
@@ -223,12 +242,13 @@ impl Poller<(PollWorkflowTaskQueueResponse, OwnedMeteredSemPermit)> for Workflow
     }
 }
 
-pub type PollWorkflowTaskBuffer = LongPollBuffer<PollWorkflowTaskQueueResponse>;
+pub(crate) type PollWorkflowTaskBuffer =
+    LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind>;
 pub(crate) fn new_workflow_task_buffer(
     client: Arc<dyn WorkerClient>,
     task_queue: TaskQueue,
     concurrent_pollers: usize,
-    semaphore: Arc<MeteredSemaphore>,
+    permit_dealer: Arc<MeteredPermitDealer<WorkflowSlotKind>>,
     shutdown: CancellationToken,
     num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
 ) -> PollWorkflowTaskBuffer {
@@ -238,7 +258,7 @@ pub(crate) fn new_workflow_task_buffer(
             let task_queue = task_queue.clone();
             async move { client.poll_workflow_task(task_queue).await }
         },
-        semaphore,
+        permit_dealer,
         concurrent_pollers,
         shutdown,
         num_pollers_handler,
@@ -246,13 +266,14 @@ pub(crate) fn new_workflow_task_buffer(
     )
 }
 
-pub type PollActivityTaskBuffer = LongPollBuffer<PollActivityTaskQueueResponse>;
+pub(crate) type PollActivityTaskBuffer =
+    LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind>;
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn new_activity_task_buffer(
     client: Arc<dyn WorkerClient>,
     task_queue: String,
     concurrent_pollers: usize,
-    semaphore: Arc<MeteredSemaphore>,
+    semaphore: Arc<MeteredPermitDealer<ActivitySlotKind>>,
     max_tps: Option<f64>,
     shutdown: CancellationToken,
     num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
@@ -283,19 +304,20 @@ pub(crate) fn new_activity_task_buffer(
 
 #[cfg(test)]
 #[derive(derive_more::Constructor)]
-pub(crate) struct MockPermittedPollBuffer<PT> {
-    sem: Arc<MeteredSemaphore>,
+pub(crate) struct MockPermittedPollBuffer<PT, SK: SlotKind> {
+    sem: Arc<MeteredPermitDealer<SK>>,
     inner: PT,
 }
 
 #[cfg(test)]
 #[async_trait::async_trait]
-impl<T, PT> Poller<(T, OwnedMeteredSemPermit)> for MockPermittedPollBuffer<PT>
+impl<T, PT, SK> Poller<(T, OwnedMeteredSemPermit<SK>)> for MockPermittedPollBuffer<PT, SK>
 where
     T: Send + Sync + 'static,
     PT: Poller<T> + Send + Sync + 'static,
+    SK: SlotKind + 'static,
 {
-    async fn poll(&self) -> Option<pollers::Result<(T, OwnedMeteredSemPermit)>> {
+    async fn poll(&self) -> Option<pollers::Result<(T, OwnedMeteredSemPermit<SK>)>> {
         let p = self
             .sem
             .acquire_owned()
@@ -321,7 +343,8 @@ where
 mod tests {
     use super::*;
     use crate::{
-        telemetry::metrics::MetricsContext, worker::client::mocks::mock_manual_workflow_client,
+        abstractions::tests::fixed_size_permit_dealer,
+        worker::client::mocks::mock_manual_workflow_client,
     };
     use futures::FutureExt;
     use std::time::Duration;
@@ -350,11 +373,7 @@ mod tests {
                 normal_name: "".to_string(),
             },
             1,
-            Arc::new(MeteredSemaphore::new(
-                10,
-                MetricsContext::no_op(),
-                |_, _| {},
-            )),
+            Arc::new(fixed_size_permit_dealer(10)),
             CancellationToken::new(),
             None::<fn(usize)>,
         );

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

@@ -45,23 +45,23 @@ use temporal_sdk_core_protos::{
 /// A validated version of a [PollWorkflowTaskQueueResponse]
 #[derive(Clone, PartialEq)]
 #[allow(clippy::manual_non_exhaustive)] // Clippy doesn't understand it's only for *in* this crate
-pub struct ValidPollWFTQResponse {
-    pub task_token: TaskToken,
-    pub task_queue: String,
-    pub workflow_execution: WorkflowExecution,
-    pub workflow_type: String,
-    pub history: History,
-    pub next_page_token: Vec<u8>,
-    pub attempt: u32,
-    pub previous_started_event_id: i64,
-    pub started_event_id: i64,
+pub(crate) struct ValidPollWFTQResponse {
+    pub(crate) task_token: TaskToken,
+    pub(crate) task_queue: String,
+    pub(crate) workflow_execution: WorkflowExecution,
+    pub(crate) workflow_type: String,
+    pub(crate) history: History,
+    pub(crate) next_page_token: Vec<u8>,
+    pub(crate) attempt: u32,
+    pub(crate) previous_started_event_id: i64,
+    pub(crate) started_event_id: i64,
     /// If this is present, `history` will be empty. This is not a very "tight" design, but it's
     /// enforced at construction time. From the `query` field.
-    pub legacy_query: Option<WorkflowQuery>,
+    pub(crate) legacy_query: Option<WorkflowQuery>,
     /// Query requests from the `queries` field
-    pub query_requests: Vec<QueryWorkflow>,
+    pub(crate) query_requests: Vec<QueryWorkflow>,
     /// Protocol messages
-    pub messages: Vec<IncomingProtocolMessage>,
+    pub(crate) messages: Vec<IncomingProtocolMessage>,
 
     /// Zero-size field to prevent explicit construction
     _cant_construct_me: (),
@@ -253,8 +253,8 @@ impl HistoryEventExt for HistoryEvent {
 }
 
 pub(crate) struct CompleteLocalActivityData {
-    pub marker_dat: LocalActivityMarkerData,
-    pub result: Result<Payload, Failure>,
+    pub(crate) marker_dat: LocalActivityMarkerData,
+    pub(crate) result: Result<Payload, Failure>,
 }
 
 pub(crate) fn validate_activity_completion(
@@ -303,23 +303,23 @@ impl TryFrom<activity_execution_result::Status> for LocalActivityExecutionResult
 /// One or both of `schedule_to_close_timeout` and `start_to_close_timeout` are guaranteed to exist.
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(Default))]
-pub struct ValidScheduleLA {
-    pub seq: u32,
-    pub activity_id: String,
-    pub activity_type: String,
-    pub attempt: u32,
-    pub original_schedule_time: Option<SystemTime>,
-    pub headers: HashMap<String, Payload>,
-    pub arguments: Vec<Payload>,
-    pub schedule_to_start_timeout: Option<Duration>,
-    pub close_timeouts: LACloseTimeouts,
-    pub retry_policy: RetryPolicy,
-    pub local_retry_threshold: Duration,
-    pub cancellation_type: ActivityCancellationType,
+pub(crate) struct ValidScheduleLA {
+    pub(crate) seq: u32,
+    pub(crate) activity_id: String,
+    pub(crate) activity_type: String,
+    pub(crate) attempt: u32,
+    pub(crate) original_schedule_time: Option<SystemTime>,
+    pub(crate) headers: HashMap<String, Payload>,
+    pub(crate) arguments: Vec<Payload>,
+    pub(crate) schedule_to_start_timeout: Option<Duration>,
+    pub(crate) close_timeouts: LACloseTimeouts,
+    pub(crate) retry_policy: RetryPolicy,
+    pub(crate) local_retry_threshold: Duration,
+    pub(crate) cancellation_type: ActivityCancellationType,
 }
 
 #[derive(Debug, Clone, Copy)]
-pub enum LACloseTimeouts {
+pub(crate) enum LACloseTimeouts {
     ScheduleOnly(Duration),
     StartOnly(Duration),
     Both { sched: Duration, start: Duration },
@@ -328,7 +328,7 @@ pub enum LACloseTimeouts {
 impl LACloseTimeouts {
     /// Splits into (schedule_to_close, start_to_close) options, one or both of which is guaranteed
     /// to be populated
-    pub fn into_sched_and_start(self) -> (Option<Duration>, Option<Duration>) {
+    pub(crate) fn into_sched_and_start(self) -> (Option<Duration>, Option<Duration>) {
         match self {
             LACloseTimeouts::ScheduleOnly(x) => (Some(x), None),
             LACloseTimeouts::StartOnly(x) => (None, Some(x)),
@@ -345,7 +345,7 @@ impl Default for LACloseTimeouts {
 }
 
 impl ValidScheduleLA {
-    pub fn from_schedule_la(v: ScheduleLocalActivity) -> Result<Self, anyhow::Error> {
+    pub(crate) fn from_schedule_la(v: ScheduleLocalActivity) -> Result<Self, anyhow::Error> {
         let original_schedule_time = v
             .original_schedule_time
             .map(|x| {
@@ -406,7 +406,7 @@ impl ValidScheduleLA {
             .clone()
             .try_into_or_none()
             .unwrap_or_else(|| Duration::from_secs(60));
-        let cancellation_type = ActivityCancellationType::from_i32(v.cancellation_type)
+        let cancellation_type = ActivityCancellationType::try_from(v.cancellation_type)
             .unwrap_or(ActivityCancellationType::WaitCancellationCompleted);
         Ok(ValidScheduleLA {
             seq: v.seq,

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

@@ -8,18 +8,15 @@ use temporal_sdk_core_protos::temporal::api::{
 
 /// A decoded & verified of a [Message] that came with a WFT.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub struct IncomingProtocolMessage {
-    pub id: String,
-    pub protocol_instance_id: String,
-    pub sequencing_id: Option<SequencingId>,
-    pub body: IncomingProtocolMessageBody,
+pub(crate) struct IncomingProtocolMessage {
+    pub(crate) id: String,
+    pub(crate) protocol_instance_id: String,
+    pub(crate) sequencing_id: Option<SequencingId>,
+    pub(crate) body: IncomingProtocolMessageBody,
 }
+
 impl IncomingProtocolMessage {
-    pub fn processable_after_event_id(&self) -> Option<i64> {
+    pub(crate) fn processable_after_event_id(&self) -> Option<i64> {
         match self.sequencing_id {
             None => Some(0),
             Some(SequencingId::EventId(id)) => Some(id),
@@ -27,6 +24,7 @@ impl IncomingProtocolMessage {
         }
     }
 }
+
 impl TryFrom<Message> for IncomingProtocolMessage {
     type Error = anyhow::Error;
 
@@ -44,11 +42,7 @@ impl TryFrom<Message> for IncomingProtocolMessage {
 /// All the protocol [Message] bodies Core understands that might come to us when receiving a new
 /// WFT.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub enum IncomingProtocolMessageBody {
+pub(crate) enum IncomingProtocolMessageBody {
     UpdateRequest(UpdateRequest),
 }
 
@@ -71,15 +65,11 @@ impl TryFrom<Option<prost_types::Any>> for IncomingProtocolMessageBody {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub struct UpdateRequest {
-    pub name: String,
-    pub headers: HashMap<String, Payload>,
-    pub input: Vec<Payload>,
-    pub meta: update::v1::Meta,
+pub(crate) struct UpdateRequest {
+    pub(crate) name: String,
+    pub(crate) headers: HashMap<String, Payload>,
+    pub(crate) input: Vec<Payload>,
+    pub(crate) meta: update::v1::Meta,
 }
 
 impl TryFrom<update::v1::Request> for UpdateRequest {

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

@@ -173,7 +173,7 @@ mod tests {
                 Some(&ApplicationFailureInfo {
                     r#type: "no retry".to_string(),
                     non_retryable: false,
-                    details: None,
+                    ..Default::default()
                 })
             )
             .is_none());
@@ -194,7 +194,7 @@ mod tests {
                 Some(&ApplicationFailureInfo {
                     r#type: "".to_string(),
                     non_retryable: true,
-                    details: None,
+                    ..Default::default()
                 })
             )
             .is_none());

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

@@ -1,12 +1,10 @@
 use futures::channel::mpsc::{channel, Receiver, Sender};
 use parking_lot::Mutex;
-use ringbuf::{Consumer, HeapRb, Producer};
+use ringbuf::{consumer::Consumer, producer::Producer, traits::Split, HeapRb};
 use std::{collections::HashMap, fmt, sync::Arc, time::SystemTime};
 use temporal_sdk_core_api::telemetry::{CoreLog, CoreLogConsumer};
 use tracing_subscriber::Layer;
 
-type CoreLogsOut = Consumer<CoreLog, Arc<HeapRb<CoreLog>>>;
-
 #[derive(Debug)]
 struct CoreLogFieldStorage(HashMap<String, serde_json::Value>);
 
@@ -102,7 +100,7 @@ where
 
 /// Core log consumer implementation backed by a ring buffer.
 pub struct CoreLogBufferedConsumer {
-    logs_in: Mutex<Producer<CoreLog, Arc<HeapRb<CoreLog>>>>,
+    logs_in: Mutex<<HeapRb<CoreLog> as Split>::Prod>,
 }
 
 impl CoreLogBufferedConsumer {
@@ -120,7 +118,7 @@ impl CoreLogBufferedConsumer {
 
 impl CoreLogConsumer for CoreLogBufferedConsumer {
     fn on_log(&self, log: CoreLog) {
-        let _ = self.logs_in.lock().push(log);
+        let _ = self.logs_in.lock().try_push(log);
     }
 }
 
@@ -132,7 +130,7 @@ impl fmt::Debug for CoreLogBufferedConsumer {
 
 /// Buffer of core logs that can be drained.
 pub struct CoreLogBuffer {
-    logs_out: CoreLogsOut,
+    logs_out: <HeapRb<CoreLog> as Split>::Cons,
 }
 
 impl CoreLogBuffer {
@@ -218,11 +216,14 @@ impl<'a> tracing::field::Visit for JsonVisitor<'a> {
 #[cfg(test)]
 mod tests {
     use crate::{
-        telemetry::construct_filter_string, telemetry::CoreLogStreamConsumer, telemetry_init,
+        telemetry::{construct_filter_string, CoreLogStreamConsumer},
+        telemetry_init,
     };
     use futures::stream::StreamExt;
-    use std::fmt;
-    use std::sync::{Arc, Mutex};
+    use std::{
+        fmt,
+        sync::{Arc, Mutex},
+    };
     use temporal_sdk_core_api::telemetry::{
         CoreLog, CoreLogConsumer, CoreTelemetry, Logger, TelemetryOptionsBuilder,
     };