@temporalio/core-bridge 1.7.0 → 1.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.3.0",
-    "@temporalio/common": "1.7.0",
+    "@temporalio/common": "1.7.2",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2b32bac62f879b35238b487d3aaed093a1e449a7"
+  "gitHead": "779561124eecdec8396e658c0a1305d343dfaff7"
 }

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

@@ -33,7 +33,7 @@ use crate::{
     workflow_handle::UntypedWorkflowHandle,
 };
 use backoff::{exponential, ExponentialBackoff, SystemClock};
-use http::uri::InvalidUri;
+use http::{uri::InvalidUri, Uri};
 use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
 use std::{
@@ -114,6 +114,14 @@ pub struct ClientOptions {
     /// Retry configuration for the server client. Default is [RetryConfig::default]
     #[builder(default)]
     pub retry_config: RetryConfig,
+
+    /// If set, override the origin used when connecting. May be useful in rare situations where tls
+    /// verification needs to use a different name from what should be set as the `:authority`
+    /// header. If [TlsConfig::domain] is set, and this is not, this will be set to
+    /// `https://<domain>`, effectively making the `:authority` header consistent with the domain
+    /// override.
+    #[builder(default)]
+    pub override_origin: Option<Uri>,
 }
 
 /// Configuration options for TLS
@@ -310,6 +318,11 @@ impl ClientOptions {
     {
         let channel = Channel::from_shared(self.target_url.to_string())?;
         let channel = self.add_tls_to_channel(channel).await?;
+        let channel = if let Some(origin) = self.override_origin.clone() {
+            channel.origin(origin)
+        } else {
+            channel
+        };
         let channel = channel.connect().await?;
         let service = ServiceBuilder::new()
             .layer_fn(|channel| GrpcMetricSvc {
@@ -347,10 +360,7 @@ impl ClientOptions {
 
     /// If TLS is configured, set the appropriate options on the provided channel and return it.
     /// Passes it through if TLS options not set.
-    async fn add_tls_to_channel(
-        &self,
-        channel: Endpoint,
-    ) -> Result<Endpoint, tonic::transport::Error> {
+    async fn add_tls_to_channel(&self, mut channel: Endpoint) -> Result<Endpoint, ClientInitError> {
         if let Some(tls_cfg) = &self.tls_cfg {
             let mut tls = tonic::transport::ClientTlsConfig::new();
 
@@ -361,6 +371,13 @@ impl ClientOptions {
 
             if let Some(domain) = &tls_cfg.domain {
                 tls = tls.domain_name(domain);
+
+                // This song and dance ultimately is just to make sure the `:authority` header ends
+                // up correct on requests while we use TLS. Setting the header directly in our
+                // interceptor doesn't work since seemingly it is overridden at some point by
+                // something lower level.
+                let uri: Uri = format!("https://{}", domain).parse()?;
+                channel = channel.origin(uri);
             }
 
             if let Some(client_opts) = &tls_cfg.client_tls_config {
@@ -369,7 +386,7 @@ impl ClientOptions {
                 tls = tls.identity(client_identity);
             }
 
-            return channel.tls_config(tls);
+            return channel.tls_config(tls).map_err(Into::into);
         }
         Ok(channel)
     }

package/sdk-core/client/src/raw.rs

@@ -740,9 +740,9 @@ proxier! {
         }
     );
     (
-        update_worker_build_id_ordering,
-        UpdateWorkerBuildIdOrderingRequest,
-        UpdateWorkerBuildIdOrderingResponse,
+        update_worker_build_id_compatibility,
+        UpdateWorkerBuildIdCompatibilityRequest,
+        UpdateWorkerBuildIdCompatibilityResponse,
         |r| {
             let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
             labels.task_q_str(r.get_ref().task_queue.clone());
@@ -750,9 +750,9 @@ proxier! {
         }
     );
     (
-        get_worker_build_id_ordering,
-        GetWorkerBuildIdOrderingRequest,
-        GetWorkerBuildIdOrderingResponse,
+        get_worker_build_id_compatibility,
+        GetWorkerBuildIdCompatibilityRequest,
+        GetWorkerBuildIdCompatibilityResponse,
         |r| {
             let mut labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
             labels.task_q_str(r.get_ref().task_queue.clone());
@@ -768,6 +768,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        poll_workflow_execution_update,
+        PollWorkflowExecutionUpdateRequest,
+        PollWorkflowExecutionUpdateResponse,
+        |r| {
+            let labels = AttachMetricLabels::namespace(r.get_ref().namespace.clone());
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         start_batch_operation,
         StartBatchOperationRequest,

package/sdk-core/core/Cargo.toml

@@ -28,6 +28,7 @@ dashmap = "5.0"
 derive_builder = "0.12"
 derive_more = "0.99"
 enum_dispatch = "0.3"
+enum-iterator = "1.4"
 flate2 = "1.0"
 futures = "0.3"
 futures-util = "0.3"

package/sdk-core/core/src/core_tests/activity_tasks.rs

@@ -58,7 +58,7 @@ use temporal_sdk_core_protos::{
     TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE,
 };
 use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, TestWorker};
-use tokio::{sync::Barrier, time::sleep};
+use tokio::{join, sync::Barrier, time::sleep};
 use tokio_util::sync::CancellationToken;
 
 fn three_tasks() -> VecDeque<PollActivityTaskQueueResponse> {
@@ -288,7 +288,7 @@ async fn activity_cancel_interrupts_poll() {
     // Perform first poll to get the activity registered
     let act = core.poll_activity_task().await.unwrap();
     // Poll should block until heartbeat is sent, issuing the cancel, and interrupting the poll
-    tokio::join! {
+    join! {
         async {
             core.record_activity_heartbeat(ActivityHeartbeat {
                 task_token: act.task_token,
@@ -984,7 +984,7 @@ async fn activity_tasks_from_completion_reserve_slots() {
     // This wf poll should *not* set the flag that it wants tasks back since both slots are
     // occupied
     let run_fut = async { worker.run_until_done().await.unwrap() };
-    tokio::join!(run_fut, act_completer);
+    join!(run_fut, act_completer);
 }
 
 #[tokio::test]
@@ -1052,9 +1052,11 @@ async fn cant_complete_activity_with_unset_result_payload() {
     )
 }
 
+#[rstest::rstest]
 #[tokio::test]
-async fn graceful_shutdown() {
+async fn graceful_shutdown(#[values(true, false)] at_max_outstanding: bool) {
     let _task_q = "q";
+    let grace_period = Duration::from_millis(200);
     let mut tasks = three_tasks();
     let mut mock_client = mock_workflow_client();
     mock_client
@@ -1067,15 +1069,21 @@ async fn graceful_shutdown() {
         .times(3)
         .returning(|_, _| Ok(Default::default()));
 
+    let max_outstanding = if at_max_outstanding { 3_usize } else { 100 };
     let worker = Worker::new_test(
         test_worker_cfg()
-            .graceful_shutdown_period(Duration::from_millis(500))
+            .graceful_shutdown_period(grace_period)
+            .max_outstanding_activities(max_outstanding)
             .build()
             .unwrap(),
         mock_client,
     );
 
     let _1 = worker.poll_activity_task().await.unwrap();
+
+    // Wait at least the grace period after one poll - ensuring it doesn't trigger prematurely
+    tokio::time::sleep(grace_period.mul_f32(1.1)).await;
+
     let _2 = worker.poll_activity_task().await.unwrap();
     let _3 = worker.poll_activity_task().await.unwrap();
 

package/sdk-core/core/src/core_tests/determinism.rs

@@ -13,8 +13,11 @@ use temporal_sdk::{
     ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext, WorkflowResult,
 };
 use temporal_sdk_core_protos::{
-    temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
-    DEFAULT_ACTIVITY_TYPE,
+    temporal::api::{
+        enums::v1::{EventType, WorkflowTaskFailedCause},
+        failure::v1::Failure,
+    },
+    TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE,
 };
 
 static DID_FAIL: AtomicBool = AtomicBool::new(false);
@@ -268,3 +271,47 @@ async fn child_wf_id_or_type_change_is_nondeterministic(
         .unwrap();
     worker.run_until_done().await.unwrap();
 }
+
+/// Repros a situation where if, upon completing a task there is some internal error which causes
+/// us to want to auto-fail the workflow task while there is also an outstanding eviction, the wf
+/// would get evicted but then try to send some info down the completion channel afterward, causing
+/// a panic.
+#[tokio::test]
+async fn repro_channel_missing_because_nondeterminism() {
+    for _ in 1..50 {
+        let wf_id = "fakeid";
+        let wf_type = DEFAULT_WORKFLOW_TYPE;
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        t.add_has_change_marker("patch-1", false);
+        let _ts = t.add_by_type(EventType::TimerStarted);
+        t.add_workflow_task_scheduled_and_started();
+
+        let mock = mock_workflow_client();
+        let mut mh =
+            MockPollCfg::from_resp_batches(wf_id, t, [1.into(), ResponseType::AllHistory], mock);
+        mh.num_expected_fails = 1;
+        let mut worker = mock_sdk_cfg(mh, |cfg| {
+            cfg.max_cached_workflows = 2;
+            cfg.ignore_evicts_on_shutdown = false;
+        });
+
+        worker.register_wf(wf_type.to_owned(), move |ctx: WfContext| async move {
+            ctx.patched("wrongid");
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(().into())
+        });
+
+        worker
+            .submit_wf(
+                wf_id.to_owned(),
+                wf_type.to_owned(),
+                vec![],
+                WorkflowOptions::default(),
+            )
+            .await
+            .unwrap();
+        worker.run_until_done().await.unwrap();
+    }
+}

package/sdk-core/core/src/core_tests/workflow_tasks.rs

@@ -1,5 +1,7 @@
 use crate::{
-    advance_fut, job_assert,
+    advance_fut,
+    internal_flags::CoreInternalFlags,
+    job_assert,
     replay::TestHistoryBuilder,
     test_help::{
         build_fake_worker, build_mock_pollers, build_multihist_mock_sg, canned_histories,
@@ -14,9 +16,9 @@ use crate::{
 use futures::{stream, FutureExt};
 use rstest::{fixture, rstest};
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::{HashMap, HashSet, VecDeque},
     sync::{
-        atomic::{AtomicBool, AtomicU64, Ordering},
+        atomic::{AtomicU64, Ordering},
         Arc,
     },
     time::Duration,
@@ -54,9 +56,7 @@ use temporal_sdk_core_protos::{
     },
     DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE,
 };
-use temporal_sdk_core_test_utils::{
-    fanout_tasks, schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers,
-};
+use temporal_sdk_core_test_utils::{fanout_tasks, start_timer_cmd, WorkerTestHelpers};
 use tokio::{
     join,
     sync::{Barrier, Semaphore},
@@ -2297,7 +2297,7 @@ async fn ensure_fetching_fail_during_complete_sends_task_failure() {
     mock.expect_get_workflow_execution_history()
         .returning(move |_, _, _| {
             error!("Called fetch second time!");
-            Ok(really_empty_fetch_resp.clone())
+            Err(tonic::Status::not_found("Ahh broken"))
         })
         .times(1);
     mock.expect_fail_workflow_task()
@@ -2380,54 +2380,36 @@ async fn lang_internal_flags() {
     core.shutdown().await;
 }
 
-// Verify we send flags to server when they're used
+// Verify we send all core internal flags on the first non-replay WFT
 #[tokio::test]
 async fn core_internal_flags() {
     let mut t = TestHistoryBuilder::default();
     t.add_by_type(EventType::WorkflowExecutionStarted);
-    t.add_full_wf_task();
-    let act_scheduled_event_id = t.add_activity_task_scheduled("act-id");
-    let act_started_event_id = t.add_activity_task_started(act_scheduled_event_id);
-    t.add_activity_task_completed(
-        act_scheduled_event_id,
-        act_started_event_id,
-        Default::default(),
-    );
-    t.add_full_wf_task();
-    t.add_workflow_execution_completed();
+    t.add_workflow_task_scheduled_and_started();
 
     let mut mh = MockPollCfg::from_resp_batches(
         "fake_wf_id",
         t,
-        [ResponseType::ToTaskNum(1), ResponseType::ToTaskNum(2)],
+        [ResponseType::ToTaskNum(1)],
         mock_workflow_client(),
     );
-    let first_poll = AtomicBool::new(true);
     mh.completion_asserts = Some(Box::new(move |c| {
-        if !first_poll.load(Ordering::Acquire) {
-            assert_matches!(c.sdk_metadata.core_used_flags.as_slice(), &[1]);
-        }
-        first_poll.store(false, Ordering::Release);
+        assert_eq!(
+            c.sdk_metadata
+                .core_used_flags
+                .iter()
+                .copied()
+                .collect::<HashSet<_>>(),
+            CoreInternalFlags::all_except_too_high()
+                .into_iter()
+                .map(|f| f as u32)
+                .collect()
+        );
     }));
     let mut mock = build_mock_pollers(mh);
     mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
     let core = mock_worker(mock);
 
-    let act = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-        act.run_id,
-        schedule_activity_cmd(
-            1,
-            "whatever",
-            "act-id",
-            ActivityCancellationType::TryCancel,
-            Duration::from_secs(60),
-            Duration::from_secs(60),
-        ),
-    ))
-    .await
-    .unwrap();
-
     let act = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&act.run_id).await;
     core.shutdown().await;

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

@@ -1,7 +1,11 @@
 //! Utilities for and tracking of internal versions which alter history in incompatible ways
 //! so that we can use older code paths for workflows executed on older core versions.
 
-use std::collections::{BTreeSet, HashSet};
+use itertools::Either;
+use std::{
+    collections::{BTreeSet, HashSet},
+    iter,
+};
 use temporal_sdk_core_protos::temporal::api::{
     history::v1::WorkflowTaskCompletedEventAttributes, sdk::v1::WorkflowTaskCompletedMetadata,
     workflowservice::v1::get_system_info_response,
@@ -15,7 +19,7 @@ use temporal_sdk_core_protos::temporal::api::{
 /// that removing older variants does not create any change in existing values. Removed flag
 /// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
 #[repr(u32)]
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug, enum_iterator::Sequence)]
 pub(crate) enum CoreInternalFlags {
     /// In this flag additional checks were added to a number of state machines to ensure that
     /// the ID and type of activities, local activities, and child workflows match during replay.
@@ -28,78 +32,85 @@ pub(crate) enum CoreInternalFlags {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InternalFlags {
-    enabled: bool,
-    core: BTreeSet<CoreInternalFlags>,
-    lang: BTreeSet<u32>,
-    core_since_last_complete: HashSet<CoreInternalFlags>,
-    lang_since_last_complete: HashSet<u32>,
+pub(crate) enum InternalFlags {
+    Enabled {
+        core: BTreeSet<CoreInternalFlags>,
+        lang: BTreeSet<u32>,
+        core_since_last_complete: HashSet<CoreInternalFlags>,
+        lang_since_last_complete: HashSet<u32>,
+    },
+    Disabled,
 }
 
 impl InternalFlags {
     pub fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
-        Self {
-            enabled: server_capabilities.sdk_metadata,
-            core: Default::default(),
-            lang: Default::default(),
-            core_since_last_complete: Default::default(),
-            lang_since_last_complete: Default::default(),
-        }
-    }
-
-    #[cfg(test)]
-    pub fn all_core_enabled() -> Self {
-        Self {
-            enabled: true,
-            core: BTreeSet::from([
-                CoreInternalFlags::IdAndTypeDeterminismChecks,
-                CoreInternalFlags::UpsertSearchAttributeOnPatch,
-            ]),
-            lang: Default::default(),
-            core_since_last_complete: Default::default(),
-            lang_since_last_complete: Default::default(),
+        match server_capabilities.sdk_metadata {
+            true => Self::Enabled {
+                core: Default::default(),
+                lang: Default::default(),
+                core_since_last_complete: Default::default(),
+                lang_since_last_complete: Default::default(),
+            },
+            false => Self::Disabled,
         }
     }
 
     pub fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
-        if !self.enabled {
-            return;
-        }
-
-        if let Some(metadata) = e.sdk_metadata.as_ref() {
-            self.core.extend(
-                metadata
-                    .core_used_flags
-                    .iter()
-                    .map(|u| CoreInternalFlags::from_u32(*u)),
-            );
-            self.lang.extend(metadata.lang_used_flags.iter());
+        if let Self::Enabled { core, lang, .. } = self {
+            if let Some(metadata) = e.sdk_metadata.as_ref() {
+                core.extend(
+                    metadata
+                        .core_used_flags
+                        .iter()
+                        .map(|u| CoreInternalFlags::from_u32(*u)),
+                );
+                lang.extend(metadata.lang_used_flags.iter());
+            }
         }
     }
 
     pub fn add_lang_used(&mut self, flags: impl IntoIterator<Item = u32>) {
-        if !self.enabled {
-            return;
+        if let Self::Enabled {
+            lang_since_last_complete,
+            ..
+        } = self
+        {
+            lang_since_last_complete.extend(flags.into_iter());
         }
-
-        self.lang_since_last_complete.extend(flags.into_iter());
     }
 
     /// Returns true if this flag may currently be used. If `should_record` is true, always returns
     /// true and records the flag as being used, for taking later via
     /// [Self::gather_for_wft_complete].
     pub fn try_use(&mut self, core_patch: CoreInternalFlags, should_record: bool) -> bool {
-        if !self.enabled {
+        match self {
+            Self::Enabled {
+                core,
+                core_since_last_complete,
+                ..
+            } => {
+                if should_record {
+                    core_since_last_complete.insert(core_patch);
+                    true
+                } else {
+                    core.contains(&core_patch)
+                }
+            }
             // If the server does not support the metadata field, we must assume we can never use
             // any internal flags since they can't be recorded for future use
-            return false;
+            Self::Disabled => false,
         }
+    }
 
-        if should_record {
-            self.core_since_last_complete.insert(core_patch);
-            true
-        } else {
-            self.core.contains(&core_patch)
+    /// Writes all known core flags to the set which should be recorded in the current WFT if not
+    /// already known. Must only be called if not replaying.
+    pub fn write_all_known(&mut self) {
+        if let Self::Enabled {
+            core_since_last_complete,
+            ..
+        } = self
+        {
+            core_since_last_complete.extend(CoreInternalFlags::all_except_too_high());
         }
     }
 
@@ -107,18 +118,39 @@ impl InternalFlags {
     /// sdk metadata message that can be combined with any existing data before sending the WFT
     /// complete
     pub fn gather_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
-        WorkflowTaskCompletedMetadata {
-            core_used_flags: self
-                .core_since_last_complete
-                .drain()
-                .map(|p| p as u32)
-                .collect(),
-            lang_used_flags: self.lang_since_last_complete.drain().collect(),
+        match self {
+            Self::Enabled {
+                core_since_last_complete,
+                lang_since_last_complete,
+                core,
+                lang,
+            } => {
+                let core_newly_used: Vec<_> = core_since_last_complete
+                    .iter()
+                    .filter(|f| !core.contains(f))
+                    .map(|p| *p as u32)
+                    .collect();
+                let lang_newly_used: Vec<_> = lang_since_last_complete
+                    .iter()
+                    .filter(|f| !lang.contains(f))
+                    .copied()
+                    .collect();
+                core.extend(core_since_last_complete.iter());
+                lang.extend(lang_since_last_complete.iter());
+                WorkflowTaskCompletedMetadata {
+                    core_used_flags: core_newly_used,
+                    lang_used_flags: lang_newly_used,
+                }
+            }
+            Self::Disabled => WorkflowTaskCompletedMetadata::default(),
         }
     }
 
-    pub fn all_lang(&self) -> &BTreeSet<u32> {
-        &self.lang
+    pub fn all_lang(&self) -> impl Iterator<Item = u32> + '_ {
+        match self {
+            Self::Enabled { lang, .. } => Either::Left(lang.iter().copied()),
+            Self::Disabled => Either::Right(iter::empty()),
+        }
     }
 }
 
@@ -130,6 +162,11 @@ impl CoreInternalFlags {
             _ => Self::TooHigh,
         }
     }
+
+    pub fn all_except_too_high() -> impl Iterator<Item = CoreInternalFlags> {
+        enum_iterator::all::<CoreInternalFlags>()
+            .filter(|f| !matches!(f, CoreInternalFlags::TooHigh))
+    }
 }
 
 #[cfg(test)]
@@ -152,4 +189,39 @@ mod tests {
         assert_matches!(gathered.core_used_flags.as_slice(), &[]);
         assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
     }
+
+    #[test]
+    fn all_have_u32_from_impl() {
+        let all_known = CoreInternalFlags::all_except_too_high();
+        for flag in all_known {
+            let as_u32 = flag as u32;
+            assert_eq!(CoreInternalFlags::from_u32(as_u32), flag);
+        }
+    }
+
+    #[test]
+    fn only_writes_new_flags() {
+        let mut f = InternalFlags::new(&Capabilities {
+            sdk_metadata: true,
+            ..Default::default()
+        });
+        f.add_lang_used([1]);
+        f.try_use(CoreInternalFlags::IdAndTypeDeterminismChecks, true);
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[1]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[1]);
+
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                core_used_flags: vec![2],
+                lang_used_flags: vec![2],
+            }),
+            ..Default::default()
+        });
+        f.add_lang_used([2]);
+        f.try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, true);
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+    }
 }

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

@@ -1,11 +1,14 @@
-use crate::abstractions::MeteredSemaphore;
-use crate::worker::activities::PermittedTqResp;
-use crate::{pollers::BoxedActPoller, MetricsContext};
+use crate::{
+    abstractions::MeteredSemaphore, pollers::BoxedActPoller, worker::activities::PermittedTqResp,
+    MetricsContext,
+};
 use futures::{stream, Stream};
-use governor::clock::DefaultClock;
-use governor::middleware::NoOpMiddleware;
-use governor::state::{InMemoryState, NotKeyed};
-use governor::RateLimiter;
+use governor::{
+    clock::DefaultClock,
+    middleware::NoOpMiddleware,
+    state::{InMemoryState, NotKeyed},
+    RateLimiter,
+};
 use std::sync::Arc;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollActivityTaskQueueResponse;
 use tokio::select;