@temporalio/core-bridge 1.9.2 → 1.10.0

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

@@ -11,15 +11,12 @@ mod wft_extraction;
 pub(crate) mod wft_poller;
 mod workflow_stream;
 
-#[cfg(feature = "save_wf_inputs")]
-pub use workflow_stream::replay_wf_state_inputs;
-
 pub(crate) use driven_workflow::DrivenWorkflow;
 pub(crate) use history_update::HistoryUpdate;
 
 use crate::{
     abstractions::{
-        dbg_panic, take_cell::TakeCell, MeteredSemaphore, TrackedOwnedMeteredSemPermit,
+        dbg_panic, take_cell::TakeCell, MeteredPermitDealer, TrackedOwnedMeteredSemPermit,
         UsedMeteredSemPermit,
     },
     internal_flags::InternalFlags,
@@ -61,7 +58,7 @@ use std::{
 };
 use temporal_sdk_core_api::{
     errors::{CompleteWfError, PollWfError},
-    worker::WorkerConfig,
+    worker::{ActivitySlotKind, WorkerConfig, WorkflowSlotKind},
 };
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -125,26 +122,26 @@ pub(crate) struct Workflows {
     /// If set, can be used to reserve activity task slots for eager-return of new activity tasks.
     activity_tasks_handle: Option<ActivitiesFromWFTsHandle>,
     /// Ensures we stay at or below this worker's maximum concurrent workflow task limit
-    wft_semaphore: Arc<MeteredSemaphore>,
+    wft_semaphore: Arc<MeteredPermitDealer<WorkflowSlotKind>>,
     local_act_mgr: Arc<LocalActivityManager>,
     ever_polled: AtomicBool,
 }
 
 pub(crate) struct WorkflowBasics {
-    pub worker_config: Arc<WorkerConfig>,
-    pub shutdown_token: CancellationToken,
-    pub metrics: MetricsContext,
-    pub server_capabilities: get_system_info_response::Capabilities,
+    pub(crate) worker_config: Arc<WorkerConfig>,
+    pub(crate) shutdown_token: CancellationToken,
+    pub(crate) metrics: MetricsContext,
+    pub(crate) server_capabilities: get_system_info_response::Capabilities,
 }
 
 pub(crate) struct RunBasics<'a> {
-    pub worker_config: Arc<WorkerConfig>,
-    pub workflow_id: String,
-    pub workflow_type: String,
-    pub run_id: String,
-    pub history: HistoryUpdate,
-    pub metrics: MetricsContext,
-    pub capabilities: &'a get_system_info_response::Capabilities,
+    pub(crate) worker_config: Arc<WorkerConfig>,
+    pub(crate) workflow_id: String,
+    pub(crate) workflow_type: String,
+    pub(crate) run_id: String,
+    pub(crate) history: HistoryUpdate,
+    pub(crate) metrics: MetricsContext,
+    pub(crate) capabilities: &'a get_system_info_response::Capabilities,
 }
 
 impl Workflows {
@@ -153,7 +150,7 @@ impl Workflows {
         basics: WorkflowBasics,
         sticky_attrs: Option<StickyExecutionAttributes>,
         client: Arc<dyn WorkerClient>,
-        wft_semaphore: Arc<MeteredSemaphore>,
+        wft_semaphore: Arc<MeteredPermitDealer<WorkflowSlotKind>>,
         wft_stream: impl Stream<Item = WFTStreamIn> + Send + 'static,
         local_activity_request_sink: impl LocalActivityRequestSink,
         local_act_mgr: Arc<LocalActivityManager>,
@@ -291,7 +288,7 @@ impl Workflows {
                     self.activation_completed(
                         WorkflowActivationCompletion {
                             run_id,
-                            status: Some(auto_fail_to_complete_status(machines_err)),
+                            status: Some(machines_err.as_failure().into()),
                         },
                         true,
                         Option::<Box<dyn Fn(PostActivateHookData) + Send>>::None,
@@ -458,7 +455,6 @@ impl Workflows {
         if let Some(h) = post_activate_hook {
             h(PostActivateHookData {
                 run_id: &run_id,
-                most_recent_event: completion_outcome.most_recently_processed_event,
                 replaying: completion_outcome.replaying,
             });
         }
@@ -514,11 +510,11 @@ impl Workflows {
         async move { rx.await.ok() }
     }
 
-    pub(super) fn available_wft_permits(&self) -> usize {
+    pub(super) fn available_wft_permits(&self) -> Option<usize> {
         self.wft_semaphore.available_permits()
     }
     #[cfg(test)]
-    pub(super) fn unused_wft_permits(&self) -> usize {
+    pub(super) fn unused_wft_permits(&self) -> Option<usize> {
         self.wft_semaphore.unused_permits()
     }
 
@@ -617,7 +613,7 @@ impl Workflows {
     /// Process eagerly returned activities from WFT completion
     fn handle_eager_activities(
         &self,
-        reserved_act_permits: Vec<TrackedOwnedMeteredSemPermit>,
+        reserved_act_permits: Vec<TrackedOwnedMeteredSemPermit<ActivitySlotKind>>,
         eager_acts: Vec<PollActivityTaskQueueResponse>,
     ) {
         if let Some(at_handle) = self.activity_tasks_handle.as_ref() {
@@ -661,7 +657,7 @@ impl Workflows {
     fn reserve_activity_slots_for_outgoing_commands(
         &self,
         commands: &mut [Command],
-    ) -> Vec<TrackedOwnedMeteredSemPermit> {
+    ) -> Vec<TrackedOwnedMeteredSemPermit<ActivitySlotKind>> {
         let mut reserved = vec![];
         for cmd in commands {
             if let Some(Attributes::ScheduleActivityTaskCommandAttributes(attrs)) =
@@ -758,30 +754,14 @@ enum ActivationOrAuto {
 /// A WFT which is considered to be using a slot for metrics purposes and being or about to be
 /// applied to workflow state.
 #[derive(derive_more::DebugCustom)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 #[debug(fmt = "PermittedWft({work:?})")]
 pub(crate) struct PermittedWFT {
     work: PreparedWFT,
-    #[cfg_attr(
-        feature = "save_wf_inputs",
-        serde(skip, default = "UsedMeteredSemPermit::fake_deserialized")
-    )]
-    permit: UsedMeteredSemPermit,
-    #[cfg_attr(
-        feature = "save_wf_inputs",
-        serde(skip, default = "HistoryPaginator::fake_deserialized")
-    )]
+    permit: UsedMeteredSemPermit<WorkflowSlotKind>,
     paginator: HistoryPaginator,
 }
 /// A WFT without a permit
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct WFTWithPaginator {
     wft: PreparedWFT,
     paginator: HistoryPaginator,
@@ -789,10 +769,6 @@ struct WFTWithPaginator {
 
 /// A WFT which has been validated and had a history update extracted from it.
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct PreparedWFT {
     task_token: TaskToken,
     attempt: u32,
@@ -803,10 +779,11 @@ struct PreparedWFT {
     update: HistoryUpdate,
     messages: Vec<IncomingProtocolMessage>,
 }
+
 impl PreparedWFT {
     /// Returns true if the contained history update is incremental (IE: expects to hit a cached
     /// workflow)
-    pub fn is_incremental(&self) -> bool {
+    fn is_incremental(&self) -> bool {
         let start_event_id = self.update.first_event_id();
         let poll_resp_is_incremental = start_event_id.map(|eid| eid > 1).unwrap_or_default();
         poll_resp_is_incremental || start_event_id.is_none()
@@ -819,18 +796,18 @@ impl PreparedWFT {
 }
 
 #[derive(Debug)]
-pub(crate) struct OutstandingTask {
-    pub info: WorkflowTaskInfo,
+struct OutstandingTask {
+    info: WorkflowTaskInfo,
     /// Set if the outstanding task has quer(ies) which must be fulfilled upon finishing replay
-    pub pending_queries: Vec<QueryWorkflow>,
-    pub start_time: Instant,
+    pending_queries: Vec<QueryWorkflow>,
+    start_time: Instant,
     /// The WFT permit owned by this task, ensures we don't exceed max concurrent WFT, and makes
     /// sure the permit is automatically freed when we delete the task.
-    pub permit: UsedMeteredSemPermit,
+    permit: UsedMeteredSemPermit<WorkflowSlotKind>,
 }
 
 impl OutstandingTask {
-    pub fn has_pending_legacy_query(&self) -> bool {
+    fn has_pending_legacy_query(&self) -> bool {
         self.pending_queries
             .iter()
             .any(|q| q.query_id == LEGACY_QUERY_ID)
@@ -840,62 +817,38 @@ impl OutstandingTask {
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum OutstandingActivation {
     /// A normal activation with a joblist
-    Normal {
-        /// True if there is an eviction in the joblist
-        contains_eviction: bool,
-        /// Number of jobs in the activation
-        num_jobs: usize,
-    },
+    Normal,
+    /// An eviction job
+    Eviction,
     /// An activation for a legacy query
     LegacyQuery,
     /// A fake activation which is never sent to lang, but used internally
     Autocomplete,
 }
 
-impl OutstandingActivation {
-    pub(crate) const fn has_only_eviction(self) -> bool {
-        matches!(
-            self,
-            OutstandingActivation::Normal {
-                contains_eviction: true,
-                num_jobs: nj
-            }
-        if nj == 1)
-    }
-    pub(crate) const fn has_eviction(self) -> bool {
-        matches!(
-            self,
-            OutstandingActivation::Normal {
-                contains_eviction: true,
-                ..
-            }
-        )
-    }
-}
-
 /// Contains important information about a given workflow task that we need to memorize while
 /// lang handles it.
 #[derive(Clone, Debug)]
-pub struct WorkflowTaskInfo {
-    pub task_token: TaskToken,
-    pub attempt: u32,
+struct WorkflowTaskInfo {
+    task_token: TaskToken,
+    attempt: u32,
     /// Exists to allow easy tagging of spans with workflow ids. Is duplicative of info inside the
     /// run machines themselves, but that can't be accessed easily. Would be nice to somehow have a
     /// shared repository, or refcounts, or whatever, for strings like these that get duped all
     /// sorts of places.
-    pub wf_id: String,
+    wf_id: String,
 }
 
 #[derive(Debug)]
-pub enum FailedActivationWFTReport {
+enum FailedActivationWFTReport {
     Report(TaskToken, WorkflowTaskFailedCause, Failure),
     ReportLegacyQueryFailure(TaskToken, Failure),
 }
 
 #[derive(Debug)]
-pub(crate) struct ServerCommandsWithWorkflowInfo {
-    pub task_token: TaskToken,
-    pub action: ActivationAction,
+struct ServerCommandsWithWorkflowInfo {
+    task_token: TaskToken,
+    action: ActivationAction,
 }
 
 #[derive(Debug)]
@@ -931,34 +884,21 @@ impl EvictionRequestResult {
 #[derive(Debug)]
 #[allow(dead_code)] // Not always used in non-test
 pub(crate) struct WorkflowStateInfo {
-    pub cached_workflows: usize,
-    pub outstanding_wft: usize,
+    pub(crate) cached_workflows: usize,
+    pub(crate) outstanding_wft: usize,
 }
 
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct WFActCompleteMsg {
     completion: ValidatedCompletion,
-    #[cfg_attr(feature = "save_wf_inputs", serde(skip))]
     response_tx: Option<oneshot::Sender<ActivationCompleteResult>>,
 }
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct LocalResolutionMsg {
     run_id: String,
     res: LocalResolution,
 }
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct PostActivationMsg {
     run_id: String,
     wft_report_status: WFTReportStatus,
@@ -966,10 +906,6 @@ struct PostActivationMsg {
     is_autocomplete: bool,
 }
 #[derive(Debug, Clone)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 struct RequestEvictMsg {
     run_id: String,
     message: String,
@@ -992,10 +928,10 @@ struct GetStateInfoMsg {
 /// Each activation completion produces one of these
 #[derive(Debug)]
 struct ActivationCompleteResult {
-    most_recently_processed_event: usize,
     replaying: bool,
     outcome: ActivationCompleteOutcome,
 }
+
 /// What needs to be done after calling [Workflows::activation_completed]
 #[derive(Debug)]
 #[allow(clippy::large_enum_variant)]
@@ -1012,10 +948,6 @@ enum ActivationCompleteOutcome {
 }
 /// Did we report, or not, completion of a WFT to server?
 #[derive(Debug, Copy, Clone)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 enum WFTReportStatus {
     Reported {
         reset_last_started_to: Option<i64>,
@@ -1146,10 +1078,6 @@ fn validate_completion(
 }
 
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 #[allow(clippy::large_enum_variant)]
 enum ValidatedCompletion {
     Success {
@@ -1165,7 +1093,7 @@ enum ValidatedCompletion {
 }
 
 impl ValidatedCompletion {
-    pub fn run_id(&self) -> &str {
+    fn run_id(&self) -> &str {
         match self {
             ValidatedCompletion::Success { run_id, .. } => run_id,
             ValidatedCompletion::Fail { run_id, .. } => run_id,
@@ -1174,15 +1102,11 @@ impl ValidatedCompletion {
 }
 
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 pub(crate) enum LocalResolution {
     LocalActivity(LocalActivityResolution),
 }
 impl LocalResolution {
-    pub fn is_la_cancel_confirmation(&self) -> bool {
+    fn is_la_cancel_confirmation(&self) -> bool {
         match self {
             LocalResolution::LocalActivity(lar) => {
                 matches!(lar.result, LocalActivityExecutionResult::Cancelled(_))
@@ -1193,17 +1117,13 @@ impl LocalResolution {
 
 #[derive(thiserror::Error, Debug, derive_more::From)]
 #[error("Lang provided workflow command with empty variant")]
-pub struct EmptyWorkflowCommandErr;
+struct EmptyWorkflowCommandErr;
 
 /// [DrivenWorkflow]s respond with these when called, to indicate what they want to do next.
 /// EX: Create a new timer, complete the workflow, etc.
 #[derive(Debug, derive_more::From, derive_more::Display)]
-#[cfg_attr(
-    feature = "save_wf_inputs",
-    derive(serde::Serialize, serde::Deserialize)
-)]
 #[allow(clippy::large_enum_variant)]
-pub enum WFCommand {
+enum WFCommand {
     /// Returned when we need to wait for the lang sdk to send us something
     NoCommandsFromLang,
     AddActivity(ScheduleActivity),
@@ -1281,7 +1201,7 @@ impl WFCommand {
     /// * Failed
     /// * Cancelled
     /// * Continue-as-new
-    pub fn is_terminal(&self) -> bool {
+    fn is_terminal(&self) -> bool {
         matches!(
             self,
             WFCommand::CompleteWorkflow(_)
@@ -1305,7 +1225,7 @@ enum CommandID {
 /// Details remembered from the workflow execution started event that we may need to recall later.
 /// Is a subset of `WorkflowExecutionStartedEventAttributes`, but avoids holding on to huge fields.
 #[derive(Debug, Clone)]
-pub struct WorkflowStartedInfo {
+struct WorkflowStartedInfo {
     workflow_task_timeout: Option<Duration>,
     memo: Option<Memo>,
     search_attrs: Option<SearchAttributes>,
@@ -1347,12 +1267,24 @@ pub(crate) enum WFMachinesError {
 }
 
 impl WFMachinesError {
-    pub fn evict_reason(&self) -> EvictionReason {
+    fn evict_reason(&self) -> EvictionReason {
         match self {
             WFMachinesError::Nondeterminism(_) => EvictionReason::Nondeterminism,
             WFMachinesError::Fatal(_) => EvictionReason::Fatal,
         }
     }
+
+    fn as_failure(&self) -> Failure {
+        Failure {
+            failure: Some(
+                temporal_sdk_core_protos::temporal::api::failure::v1::Failure::application_failure(
+                    self.to_string(),
+                    false,
+                ),
+            ),
+            force_cause: WorkflowTaskFailedCause::from(self.evict_reason()) as i32,
+        }
+    }
 }
 
 impl From<TimestampError> for WFMachinesError {
@@ -1367,22 +1299,6 @@ impl From<anyhow::Error> for WFMachinesError {
     }
 }
 
-fn auto_fail_to_complete_status(err: WFMachinesError) -> workflow_activation_completion::Status {
-    workflow_activation_completion::Status::Failed(Failure {
-        failure: Some(
-            temporal_sdk_core_protos::temporal::api::failure::v1::Failure {
-                message: "Error while processing workflow task".to_string(),
-                source: err.to_string(),
-                stack_trace: "".to_string(),
-                encoded_attributes: None,
-                cause: None,
-                failure_info: None,
-            },
-        ),
-        force_cause: WorkflowTaskFailedCause::from(err.evict_reason()) as i32,
-    })
-}
-
 pub(crate) trait LocalActivityRequestSink: Send + Sync + 'static {
     fn sink_reqs(&self, reqs: Vec<LocalActRequest>) -> Vec<LocalActivityResolution>;
 }
@@ -1390,10 +1306,6 @@ pub(crate) trait LocalActivityRequestSink: Send + Sync + 'static {
 #[derive(derive_more::Constructor)]
 pub(super) struct LAReqSink {
     lam: Arc<LocalActivityManager>,
-    /// If we're recording WF inputs, we also need to store immediate resolutions so they're
-    /// available on replay.
-    #[allow(dead_code)] // sometimes appears unused due to feature flagging
-    recorder: Option<UnboundedSender<Vec<u8>>>,
 }
 
 impl LocalActivityRequestSink for LAReqSink {
@@ -1401,16 +1313,7 @@ impl LocalActivityRequestSink for LAReqSink {
         if reqs.is_empty() {
             return vec![];
         }
-
-        #[allow(clippy::let_and_return)] // When feature is off clippy doesn't like this
-        let res = self.lam.enqueue(reqs);
-
-        // We always save when there are any reqs, even if the response might be empty, so that
-        // calls/responses are 1:1
-        #[cfg(feature = "save_wf_inputs")]
-        self.write_req(&res);
-
-        res
+        self.lam.enqueue(reqs)
     }
 }
 

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

@@ -22,7 +22,7 @@ pub(super) struct RunCache {
 }
 
 impl RunCache {
-    pub fn new(
+    pub(super) fn new(
         worker_config: Arc<WorkerConfig>,
         server_capabilities: get_system_info_response::Capabilities,
         local_activity_request_sink: impl LocalActivityRequestSink,
@@ -46,7 +46,7 @@ impl RunCache {
         }
     }
 
-    pub fn instantiate_or_update(&mut self, pwft: PermittedWFT) -> RunUpdateAct {
+    pub(super) fn instantiate_or_update(&mut self, pwft: PermittedWFT) -> RunUpdateAct {
         let cur_num_cached_runs = self.runs.len();
         let run_id = pwft.work.execution.run_id.clone();
 
@@ -80,44 +80,53 @@ impl RunCache {
         self.metrics.cache_size(cur_num_cached_runs as u64 + 1);
         rur
     }
-    pub fn remove(&mut self, k: &str) -> Option<ManagedRun> {
+
+    pub(super) fn remove(&mut self, k: &str) -> Option<ManagedRun> {
         let r = self.runs.pop(k);
         self.metrics.cache_size(self.len() as u64);
         self.metrics.cache_eviction();
         r
     }
 
-    pub fn get_mut(&mut self, k: &str) -> Option<&mut ManagedRun> {
+    pub(super) fn get_mut(&mut self, k: &str) -> Option<&mut ManagedRun> {
         self.runs.get_mut(k)
     }
-    pub fn get(&mut self, k: &str) -> Option<&ManagedRun> {
+
+    pub(super) fn get(&mut self, k: &str) -> Option<&ManagedRun> {
         self.runs.get(k)
     }
 
     /// Returns the current least-recently-used run. Returns `None` when cache empty.
-    pub fn current_lru_run(&self) -> Option<&str> {
+    pub(super) fn current_lru_run(&self) -> Option<&str> {
         self.runs.peek_lru().map(|(run_id, _)| run_id.as_str())
     }
+
     /// Returns an iterator yielding cached runs in LRU order
-    pub fn runs_lru_order(&self) -> impl Iterator<Item = (&str, &ManagedRun)> {
+    pub(super) fn runs_lru_order(&self) -> impl Iterator<Item = (&str, &ManagedRun)> {
         self.runs.iter().rev().map(|(k, v)| (k.as_str(), v))
     }
-    pub fn peek(&self, k: &str) -> Option<&ManagedRun> {
+
+    pub(super) fn peek(&self, k: &str) -> Option<&ManagedRun> {
         self.runs.peek(k)
     }
-    pub fn has_run(&self, k: &str) -> bool {
+
+    pub(super) fn has_run(&self, k: &str) -> bool {
         self.runs.contains(k)
     }
-    pub fn handles(&self) -> impl Iterator<Item = &ManagedRun> {
+
+    pub(super) fn handles(&self) -> impl Iterator<Item = &ManagedRun> {
         self.runs.iter().map(|(_, v)| v)
     }
-    pub fn is_full(&self) -> bool {
+
+    pub(super) fn is_full(&self) -> bool {
         self.runs.cap().get() == self.runs.len()
     }
-    pub fn len(&self) -> usize {
+
+    pub(super) fn len(&self) -> usize {
         self.runs.len()
     }
-    pub fn cache_capacity(&self) -> usize {
+
+    pub(super) fn cache_capacity(&self) -> usize {
         self.worker_config.max_cached_workflows
     }
 }

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

@@ -12,6 +12,7 @@ use crate::{
 use futures::Stream;
 use futures_util::{stream, stream::PollNext, FutureExt, StreamExt};
 use std::{future, sync::Arc};
+use temporal_sdk_core_api::worker::{WorkflowSlotInfo, WorkflowSlotKind};
 use temporal_sdk_core_protos::TaskToken;
 use tracing::Span;
 
@@ -21,7 +22,11 @@ pub(super) struct WFTExtractor {}
 
 pub(super) enum WFTExtractorOutput {
     NewWFT(PermittedWFT),
-    FetchResult(PermittedWFT, Arc<HistfetchRC>),
+    FetchResult(
+        PermittedWFT,
+        // Field isn't read, but we need to hold on to it.
+        #[allow(dead_code)] Arc<HistfetchRC>,
+    ),
     NextPage {
         paginator: HistoryPaginator,
         update: HistoryUpdate,
@@ -36,7 +41,13 @@ pub(super) enum WFTExtractorOutput {
     PollerDead,
 }
 
-pub(crate) type WFTStreamIn = Result<(ValidPollWFTQResponse, OwnedMeteredSemPermit), tonic::Status>;
+pub(crate) type WFTStreamIn = Result<
+    (
+        ValidPollWFTQResponse,
+        OwnedMeteredSemPermit<WorkflowSlotKind>,
+    ),
+    tonic::Status,
+>;
 #[derive(derive_more::From, Debug)]
 pub(super) enum HistoryFetchReq {
     Full(CacheMissFetchReq, Arc<HistfetchRC>),
@@ -64,8 +75,10 @@ impl WFTExtractor {
                             let tt = wft.task_token.clone();
                             Ok(match HistoryPaginator::from_poll(wft, client).await {
                                 Ok((pag, prep)) => WFTExtractorOutput::NewWFT(PermittedWFT {
+                                    permit: permit.into_used(WorkflowSlotInfo {
+                                        workflow_type: prep.workflow_type.as_str(),
+                                    }),
                                     work: prep,
-                                    permit: permit.into_used(),
                                     paginator: pag,
                                 }),
                                 Err(err) => WFTExtractorOutput::FailedFetch {

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

@@ -5,12 +5,21 @@ use crate::{
     MetricsContext,
 };
 use futures::{stream, Stream};
+use temporal_sdk_core_api::worker::WorkflowSlotKind;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 
 pub(crate) fn new_wft_poller(
     poller: BoxedWFPoller,
     metrics: MetricsContext,
-) -> impl Stream<Item = Result<(ValidPollWFTQResponse, OwnedMeteredSemPermit), tonic::Status>> {
+) -> impl Stream<
+    Item = Result<
+        (
+            ValidPollWFTQResponse,
+            OwnedMeteredSemPermit<WorkflowSlotKind>,
+        ),
+        tonic::Status,
+    >,
+> {
     stream::unfold((poller, metrics), |(poller, metrics)| async move {
         loop {
             return match poller.poll().await {
@@ -66,10 +75,12 @@ pub(crate) fn validate_wft(
 mod tests {
     use super::*;
     use crate::{
-        abstractions::MeteredSemaphore, pollers::MockPermittedPollBuffer, test_help::mock_poller,
+        abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer,
+        test_help::mock_poller,
     };
     use futures::{pin_mut, StreamExt};
     use std::sync::Arc;
+    use temporal_sdk_core_api::worker::WorkflowSlotKind;
 
     #[tokio::test]
     async fn poll_timeouts_do_not_produce_responses() {
@@ -80,11 +91,7 @@ mod tests {
             .returning(|| Some(Ok(PollWorkflowTaskQueueResponse::default())));
         mock_poller.expect_poll().times(1).returning(|| None);
         mock_poller.expect_shutdown().times(1).returning(|| ());
-        let sem = Arc::new(MeteredSemaphore::new(
-            10,
-            MetricsContext::no_op(),
-            MetricsContext::available_task_slots,
-        ));
+        let sem = Arc::new(fixed_size_permit_dealer::<WorkflowSlotKind>(10));
         let stream = new_wft_poller(
             Box::new(MockPermittedPollBuffer::new(sem, mock_poller)),
             MetricsContext::no_op(),
@@ -100,11 +107,7 @@ mod tests {
             .expect_poll()
             .times(1)
             .returning(|| Some(Err(tonic::Status::internal("ahhh"))));
-        let sem = Arc::new(MeteredSemaphore::new(
-            10,
-            MetricsContext::no_op(),
-            MetricsContext::available_task_slots,
-        ));
+        let sem = Arc::new(fixed_size_permit_dealer::<WorkflowSlotKind>(10));
         let stream = new_wft_poller(
             Box::new(MockPermittedPollBuffer::new(sem, mock_poller)),
             MetricsContext::no_op(),