@temporalio/core-bridge 0.19.2 → 0.20.0

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

@@ -15,7 +15,7 @@ use crate::{
     worker::{LocalActRequest, LocalActivityResolution},
 };
 use machines::WorkflowMachines;
-use std::{result, sync::mpsc::Sender};
+use std::{result, sync::mpsc::Sender, time::Duration};
 use temporal_sdk_core_protos::{
     coresdk::{workflow_activation::WorkflowActivation, workflow_commands::*},
     temporal::api::command::v1::Command as ProtoCommand,
@@ -213,6 +213,7 @@ pub enum WFCommand {
     RequestCancelExternalWorkflow(RequestCancelExternalWorkflowExecution),
     SignalExternalWorkflow(SignalExternalWorkflowExecution),
     CancelSignalWorkflow(CancelSignalWorkflow),
+    UpsertSearchAttributes(UpsertWorkflowSearchAttributes),
 }
 
 impl TryFrom<WorkflowCommand> for WFCommand {
@@ -253,6 +254,9 @@ impl TryFrom<WorkflowCommand> for WFCommand {
             workflow_command::Variant::RequestCancelLocalActivity(s) => {
                 Ok(Self::RequestCancelLocalActivity(s))
             }
+            workflow_command::Variant::UpsertWorkflowSearchAttributesCommandAttributes(s) => {
+                Ok(Self::UpsertSearchAttributes(s))
+            }
         }
     }
 }
@@ -267,6 +271,14 @@ enum CommandID {
     CancelExternal(u32),
 }
 
+/// 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 {
+    workflow_task_timeout: Option<Duration>,
+    workflow_execution_timeout: Option<Duration>,
+}
+
 #[cfg(test)]
 pub mod managed_wf {
     use super::*;

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

@@ -7,8 +7,9 @@ use crate::{
     pending_activations::PendingActivations,
     protosext::{ValidPollWFTQResponse, WorkflowActivationExt},
     telemetry::metrics::MetricsContext,
-    worker::{LocalActRequest, LocalActivityResolution},
+    worker::{client::WorkerClientBag, LocalActRequest, LocalActivityResolution},
     workflow::{
+        history_update::NextPageToken,
         machines::WFMachinesError,
         workflow_tasks::{
             cache_manager::WorkflowCacheManager, concurrency_manager::WorkflowConcurrencyManager,
@@ -26,15 +27,13 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use temporal_client::ServerGatewayApis;
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_activation::{
-            create_query_activation, remove_from_cache::EvictionReason, workflow_activation_job,
-            QueryWorkflow, WorkflowActivation,
+            create_query_activation, query_to_job, remove_from_cache::EvictionReason,
+            workflow_activation_job, QueryWorkflow, WorkflowActivation,
         },
         workflow_commands::QueryResult,
-        FromPayloadsExt,
     },
     temporal::api::command::v1::Command as ProtoCommand,
     TaskToken,
@@ -120,8 +119,6 @@ pub(crate) enum NewWfTaskOutcome {
     /// The workflow task should be auto-completed with an empty command list, as it must be replied
     /// to but there is no meaningful work for lang to do.
     Autocomplete,
-    /// Workflow task had partial history and workflow was not present in the cache.
-    CacheMiss,
     /// The workflow task ran into problems while being applied and we must now evict the workflow
     Evict(WorkflowUpdateError),
     /// No action should be taken. Possibly we are waiting for local activities to complete
@@ -298,7 +295,7 @@ impl WorkflowTaskManager {
     pub(crate) async fn apply_new_poll_resp(
         &self,
         work: ValidPollWFTQResponse,
-        gateway: Arc<dyn ServerGatewayApis + Send + Sync>,
+        client: Arc<WorkerClientBag>,
     ) -> NewWfTaskOutcome {
         let mut work = if let Some(w) = self.workflow_machines.buffer_resp_if_outstanding_work(work)
         {
@@ -311,25 +308,22 @@ impl WorkflowTaskManager {
             task_token = %&work.task_token,
             history_length = %work.history.events.len(),
             attempt = %work.attempt,
+            run_id = %work.workflow_execution.run_id,
             "Applying new workflow task from server"
         );
         let task_start_time = Instant::now();
 
         // Check if there is a legacy query we either need to immediately issue an activation for
         // (if there is no more replay work to do) or we need to store for later answering.
-        let legacy_query = work.legacy_query.take().map(|q| QueryWorkflow {
-            query_id: LEGACY_QUERY_ID.to_string(),
-            query_type: q.query_type,
-            arguments: Vec::from_payloads(q.query_args),
-        });
+        let legacy_query = work
+            .legacy_query
+            .take()
+            .map(|q| query_to_job(LEGACY_QUERY_ID.to_string(), q));
 
         let (info, mut next_activation) =
-            match self.instantiate_or_update_workflow(work, gateway).await {
+            match self.instantiate_or_update_workflow(work, client).await {
                 Ok((info, next_activation)) => (info, next_activation),
                 Err(e) => {
-                    if let WFMachinesError::CacheMiss = e.source {
-                        return NewWfTaskOutcome::CacheMiss;
-                    }
                     return NewWfTaskOutcome::Evict(e);
                 }
             };
@@ -337,7 +331,7 @@ impl WorkflowTaskManager {
         // Immediately dispatch query activation if no other jobs
         let legacy_query = if next_activation.jobs.is_empty() {
             if let Some(lq) = legacy_query {
-                debug!("Dispatching legacy query {:?}", &lq);
+                debug!("Dispatching legacy query {}", &lq);
                 next_activation
                     .jobs
                     .push(workflow_activation_job::Variant::QueryWorkflow(lq).into());
@@ -467,9 +461,8 @@ impl WorkflowTaskManager {
 
                         let wft_timeout: Duration = wfm
                             .machines
-                            .started_attrs()
-                            .and_then(|attrs| attrs.workflow_task_timeout.clone())
-                            .and_then(|tt| tt.try_into().ok())
+                            .get_started_info()
+                            .and_then(|attrs| attrs.workflow_task_timeout)
                             .ok_or_else(|| {
                                 WFMachinesError::Fatal(
                                     "Workflow's start attribs were missing a well formed task timeout"
@@ -584,7 +577,7 @@ impl WorkflowTaskManager {
     async fn instantiate_or_update_workflow(
         &self,
         poll_wf_resp: ValidPollWFTQResponse,
-        gateway: Arc<dyn ServerGatewayApis + Send + Sync>,
+        client: Arc<WorkerClientBag>,
     ) -> Result<(WorkflowTaskInfo, WorkflowActivation), WorkflowUpdateError> {
         let run_id = poll_wf_resp.workflow_execution.run_id.clone();
 
@@ -593,22 +586,39 @@ impl WorkflowTaskManager {
             task_token: poll_wf_resp.task_token,
         };
 
+        let poll_resp_is_incremental = poll_wf_resp
+            .history
+            .events
+            .get(0)
+            .map(|ev| ev.event_id > 1)
+            .unwrap_or_default();
+
+        let page_token = if !self.workflow_machines.exists(&run_id) && poll_resp_is_incremental {
+            debug!(run_id=?run_id, "Workflow task has partial history, but workflow is not in \
+                   cache. Will fetch history");
+            self.metrics.sticky_cache_miss();
+            NextPageToken::FetchFromStart
+        } else {
+            poll_wf_resp.next_page_token.into()
+        };
+        let history_update = HistoryUpdate::new(
+            HistoryPaginator::new(
+                poll_wf_resp.history,
+                poll_wf_resp.workflow_execution.workflow_id.clone(),
+                poll_wf_resp.workflow_execution.run_id,
+                page_token,
+                client.clone(),
+            ),
+            poll_wf_resp.previous_started_event_id,
+        );
+
         match self
             .workflow_machines
             .create_or_update(
                 &run_id,
-                HistoryUpdate::new(
-                    HistoryPaginator::new(
-                        poll_wf_resp.history,
-                        poll_wf_resp.workflow_execution.workflow_id.clone(),
-                        poll_wf_resp.workflow_execution.run_id.clone(),
-                        poll_wf_resp.next_page_token,
-                        gateway.clone(),
-                    ),
-                    poll_wf_resp.previous_started_event_id,
-                ),
+                history_update,
                 &poll_wf_resp.workflow_execution.workflow_id,
-                &gateway.get_options().namespace,
+                client.namespace(),
                 &poll_wf_resp.workflow_type,
                 &self.metrics,
             )

package/sdk-core/core-api/Cargo.toml

@@ -2,14 +2,22 @@
 name = "temporal-sdk-core-api"
 version = "0.1.0"
 edition = "2021"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = "LICENSE.txt"
+description = "Interface definitions for the Temporal Core SDK"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
-derive_builder = "0.10"
+derive_builder = "0.11"
 log = "0.4"
+opentelemetry = "0.17"
 prost-types = "0.9"
 thiserror = "1.0"
 tonic = "0.6"

package/sdk-core/core-api/LICENSE.txt

@@ -0,0 +1,23 @@
+Temporal Core SDK
+
+The MIT License
+
+Copyright (c) 2021 Temporal Technologies, Inc. All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/sdk-core/core-api/src/errors.rs

@@ -1,29 +1,17 @@
 //! Error types exposed by public APIs
 
 use prost_types::TimestampOutOfSystemRangeError;
-use temporal_client::GatewayInitError;
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityExecutionResult,
     workflow_activation::remove_from_cache::EvictionReason,
     workflow_completion::WorkflowActivationCompletion,
 };
 
-/// Errors thrown during initialization of [crate::Core]
-#[derive(thiserror::Error, Debug)]
-pub enum CoreInitError {
-    /// Server connection error. Crashing and restarting the worker is likely best.
-    #[error("Server connection error: {0:?}")]
-    GatewayInitError(#[from] GatewayInitError),
-    /// There was a problem initializing telemetry
-    #[error("Telemetry initialization error: {0:?}")]
-    TelemetryInitError(anyhow::Error),
-}
-
-/// Errors thrown by [crate::Core::poll_workflow_activation]
+/// Errors thrown by [crate::Worker::poll_workflow_activation]
 #[derive(thiserror::Error, Debug)]
 pub enum PollWfError {
-    /// [crate::Core::shutdown] was called, and there are no more replay tasks to be handled. Lang
-    /// must call [crate::Core::complete_workflow_activation] for any remaining tasks, and then may
+    /// [crate::Worker::shutdown] was called, and there are no more replay tasks to be handled. Lang
+    /// must call [crate::Worker::complete_workflow_activation] for any remaining tasks, and then may
     /// exit.
     #[error("Core is shut down and there are no more workflow replay tasks")]
     ShutDown,
@@ -36,15 +24,12 @@ pub enum PollWfError {
     /// even though we already cancelled it)
     #[error("Unhandled error when auto-completing workflow task: {0:?}")]
     AutocompleteError(#[from] CompleteWfError),
-    /// There is no worker registered for the queue being polled
-    #[error("No worker registered for queue: {0}")]
-    NoWorkerForQueue(String),
 }
 
-/// Errors thrown by [crate::Core::poll_activity_task]
+/// Errors thrown by [crate::Worker::poll_activity_task]
 #[derive(thiserror::Error, Debug)]
 pub enum PollActivityError {
-    /// [crate::Core::shutdown] was called, we will no longer fetch new activity tasks. Lang must
+    /// [crate::Worker::shutdown] was called, we will no longer fetch new activity tasks. Lang must
     /// ensure it is finished with any workflow replay, see [PollWfError::ShutDown]
     #[error("Core is shut down")]
     ShutDown,
@@ -52,12 +37,9 @@ pub enum PollActivityError {
     /// errors, so lang should consider this fatal.
     #[error("Unhandled grpc error when activity polling: {0:?}")]
     TonicError(#[from] tonic::Status),
-    /// There is no worker registered for the queue being polled
-    #[error("No worker registered for queue: {0}")]
-    NoWorkerForQueue(String),
 }
 
-/// Errors thrown by [crate::Core::complete_workflow_activation]
+/// Errors thrown by [crate::Worker::complete_workflow_activation]
 #[derive(thiserror::Error, Debug)]
 #[allow(clippy::large_enum_variant)]
 pub enum CompleteWfError {
@@ -78,7 +60,7 @@ pub enum CompleteWfError {
     TonicError(#[from] tonic::Status),
 }
 
-/// Errors thrown by [crate::Core::complete_activity_task]
+/// Errors thrown by [crate::Worker::complete_activity_task]
 #[derive(thiserror::Error, Debug)]
 pub enum CompleteActivityError {
     /// Lang SDK sent us a malformed activity completion. This likely means a bug in the lang sdk.
@@ -98,14 +80,6 @@ pub enum CompleteActivityError {
     NoWorkerForQueue(String),
 }
 
-/// Errors thrown by [crate::Core::register_worker]
-#[derive(thiserror::Error, Debug)]
-pub enum WorkerRegistrationError {
-    /// A worker has already been registered on this queue
-    #[error("Worker already registered for queue: {0}")]
-    WorkerAlreadyRegisteredForQueue(String),
-}
-
 /// Errors thrown inside of workflow machines
 #[derive(thiserror::Error, Debug)]
 pub enum WFMachinesError {
@@ -116,10 +90,6 @@ pub enum WFMachinesError {
 
     #[error("Unrecoverable network error while fetching history: {0}")]
     HistoryFetchingError(tonic::Status),
-
-    /// Should always be caught internally and turned into a workflow task failure
-    #[error("Unable to process partial event history because workflow is no longer cached.")]
-    CacheMiss,
 }
 
 impl WFMachinesError {
@@ -129,7 +99,6 @@ impl WFMachinesError {
             WFMachinesError::Fatal(_) | WFMachinesError::HistoryFetchingError(_) => {
                 EvictionReason::Fatal
             }
-            WFMachinesError::CacheMiss => EvictionReason::CacheMiss,
         }
     }
 }

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

@@ -2,39 +2,25 @@ pub mod errors;
 pub mod worker;
 
 use crate::{
-    errors::{
-        CompleteActivityError, CompleteWfError, PollActivityError, PollWfError,
-        WorkerRegistrationError,
-    },
+    errors::{CompleteActivityError, CompleteWfError, PollActivityError, PollWfError},
     worker::WorkerConfig,
 };
 use log::Level;
-use std::{
-    sync::Arc,
-    time::{Duration, SystemTime, UNIX_EPOCH},
-};
-use temporal_client::ServerGatewayApis;
+use opentelemetry::metrics::Meter;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use temporal_sdk_core_protos::coresdk::{
     activity_task::ActivityTask, workflow_activation::WorkflowActivation,
     workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat, ActivityTaskCompletion,
 };
 
-/// This trait is the primary way by which language specific SDKs interact with the core SDK. It is
-/// expected that only one instance of an implementation will exist for the lifetime of the
-/// worker(s) using it.
+/// This trait is the primary way by which language specific SDKs interact with the core SDK.
+/// It represents one worker, which has a (potentially shared) client for connecting to the service
+/// and is bound to a specific task queue.
 #[async_trait::async_trait]
-pub trait Core: Send + Sync {
-    /// Register a worker with core. Workers poll on a specific task queue, and when calling core's
-    /// poll functions, you must provide a task queue name. If there was already a worker registered
-    /// with the same task queue name, it will be shut down and a new one will be created.
-    fn register_worker(&self, config: WorkerConfig) -> Result<(), WorkerRegistrationError>;
-
-    /// Ask the core for some work, returning a [WorkflowActivation]. It is then the language SDK's
-    /// responsibility to call the appropriate workflow code with the provided inputs. Blocks
-    /// indefinitely until such work is available or [Core::shutdown] is called.
-    ///
-    /// The returned activation is guaranteed to be for the same task queue / worker which was
-    /// provided as the `task_queue` argument.
+pub trait Worker: Send + Sync {
+    /// Ask the worker for some work, returning a [WorkflowActivation]. It is then the language
+    /// SDK's responsibility to call the appropriate workflow code with the provided inputs. Blocks
+    /// indefinitely until such work is available or [Worker::shutdown] is called.
     ///
     /// It is important to understand that all activations must be responded to. There can only
     /// be one outstanding activation for a particular run of a workflow at any time. If an
@@ -48,49 +34,41 @@ pub trait Core: Send + Sync {
     ///
     /// It is rarely a good idea to call poll concurrently. It handles polling the server
     /// concurrently internally.
-    ///
-    /// TODO: Examples
-    async fn poll_workflow_activation(
-        &self,
-        task_queue: &str,
-    ) -> Result<WorkflowActivation, PollWfError>;
+    async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollWfError>;
 
-    /// Ask the core for some work, returning an [ActivityTask]. It is then the language SDK's
+    /// Ask the worker for some work, returning an [ActivityTask]. It is then the language SDK's
     /// responsibility to call the appropriate activity code with the provided inputs. Blocks
-    /// indefinitely until such work is available or [Core::shutdown] is called.
+    /// indefinitely until such work is available or [Worker::shutdown] is called.
     ///
     /// The returned activation is guaranteed to be for the same task queue / worker which was
     /// provided as the `task_queue` argument.
     ///
     /// It is rarely a good idea to call poll concurrently. It handles polling the server
     /// concurrently internally.
-    ///
-    /// TODO: Examples
-    async fn poll_activity_task(&self, task_queue: &str)
-        -> Result<ActivityTask, PollActivityError>;
+    async fn poll_activity_task(&self) -> Result<ActivityTask, PollActivityError>;
 
-    /// Tell the core that a workflow activation has completed. May be freely called concurrently.
+    /// Tell the worker that a workflow activation has completed. May be freely called concurrently.
     async fn complete_workflow_activation(
         &self,
         completion: WorkflowActivationCompletion,
     ) -> Result<(), CompleteWfError>;
 
-    /// Tell the core that an activity has finished executing. May be freely called concurrently.
+    /// Tell the worker that an activity has finished executing. May be freely called concurrently.
     async fn complete_activity_task(
         &self,
         completion: ActivityTaskCompletion,
     ) -> Result<(), CompleteActivityError>;
 
-    /// Notify workflow that an activity is still alive. Long running activities that take longer
-    /// than `activity_heartbeat_timeout` to finish must call this function in order to report
-    /// progress, otherwise the activity will timeout and a new attempt will be scheduled.
+    /// Notify the Temporal service that an activity is still alive. Long running activities that
+    /// take longer than `activity_heartbeat_timeout` to finish must call this function in order to
+    /// report progress, otherwise the activity will timeout and a new attempt will be scheduled.
     ///
     /// The first heartbeat request will be sent immediately, subsequent rapid calls to this
     /// function will result in heartbeat requests being aggregated and the last one received during
     /// the aggregation period will be sent to the server, where that period is defined as half the
     /// heartbeat timeout.
     ///
-    /// Unlike java/go SDKs we do not return cancellation status as part of heartbeat response and
+    /// Unlike Java/Go SDKs we do not return cancellation status as part of heartbeat response and
     /// instead send it as a separate activity task to the lang, decoupling heartbeat and
     /// cancellation processing.
     ///
@@ -104,27 +82,36 @@ pub trait Core: Send + Sync {
 
     /// Request that a workflow be evicted by its run id. This will generate a workflow activation
     /// with the eviction job inside it to be eventually returned by
-    /// [Core::poll_workflow_activation]. If the workflow had any existing outstanding activations,
+    /// [Worker::poll_workflow_activation]. If the workflow had any existing outstanding activations,
     /// such activations are invalidated and subsequent completions of them will do nothing and log
     /// a warning.
-    fn request_workflow_eviction(&self, task_queue: &str, run_id: &str);
+    fn request_workflow_eviction(&self, run_id: &str);
+
+    /// Return this worker's config
+    fn get_config(&self) -> &WorkerConfig;
 
-    /// Returns core's instance of the [ServerGatewayApis] implementor it is using.
-    fn server_gateway(&self) -> Arc<dyn ServerGatewayApis + Send + Sync>;
+    /// TODO: Will be replaced/fixed/whatever by shutdown refactoring
+    fn initiate_shutdown(&self);
 
     /// Initiates async shutdown procedure, eventually ceases all polling of the server and shuts
-    /// down all registered workers. [Core::poll_workflow_activation] should be called until it
+    /// down this worker. [Worker::poll_workflow_activation] should be called until it
     /// returns [PollWfError::ShutDown] to ensure that any workflows which are still undergoing
     /// replay have an opportunity to finish. This means that the lang sdk will need to call
-    /// [Core::complete_workflow_activation] for those workflows until they are done. At that point,
-    /// the lang SDK can end the process, or drop the [Core] instance, which will close the
+    /// [Worker::complete_workflow_activation] for those workflows until they are done. At that point,
+    /// the lang SDK can end the process, or drop the [Worker] instance, which will close the
     /// connection.
     async fn shutdown(&self);
 
-    /// Shut down a specific worker. Will cease all polling on the task queue and future attempts
-    /// to poll that queue will return [PollWfError::NoWorkerForQueue].
-    async fn shutdown_worker(&self, task_queue: &str);
+    /// Completes shutdown and frees all resources. You should avoid simply dropping workers, as
+    /// this does not allow async tasks to report any panics that may have occurred cleanly.
+    ///
+    /// This should be called only after [Worker::shutdown] has resolved.
+    async fn finalize_shutdown(self);
+}
 
+/// Should be backed by a process-wide singleton who is responsible for telemetry and logging
+/// management.
+pub trait CoreTelemetry {
     /// Core buffers logs that should be shuttled over to lang so that they may be rendered with
     /// the user's desired logging library. Use this function to grab the most recent buffered logs
     /// since the last time it was called. A fixed number of such logs are retained at maximum, with
@@ -133,6 +120,11 @@ pub trait Core: Send + Sync {
     /// Returns the list of logs from oldest to newest. Returns an empty vec if the feature is not
     /// configured.
     fn fetch_buffered_logs(&self) -> Vec<CoreLog>;
+
+    /// If metrics gathering is enabled, returns the OTel meter for core telemetry, which can be
+    /// used to create metrics instruments, or passed to things that create/record metrics (ex:
+    /// clients).
+    fn get_metric_meter(&self) -> Option<&Meter>;
 }
 
 /// A log line (which ultimately came from a tracing event) exported from Core->Lang

package/sdk-core/core-api/src/worker.rs

@@ -4,8 +4,9 @@ use std::time::Duration;
 #[derive(Debug, Clone, derive_builder::Builder)]
 #[builder(setter(into), build_fn(validate = "Self::validate"))]
 #[non_exhaustive]
-// TODO: per-second queue limits
 pub struct WorkerConfig {
+    /// The Temporal service namespace this worker is bound to
+    pub namespace: String,
     /// What task queue will this worker poll from? This task queue name will be used for both
     /// workflow and activity polling.
     pub task_queue: String,
@@ -45,7 +46,7 @@ pub struct WorkerConfig {
     #[builder(default = "5")]
     pub max_concurrent_at_polls: usize,
     /// If set to true this worker will only handle workflow tasks and local activities, it will not
-    /// poll for activity tasks. This option exists because
+    /// poll for activity tasks.
     #[builder(default = "false")]
     pub no_remote_activities: bool,
     /// How long a workflow task is allowed to sit on the sticky queue before it is timed out
@@ -63,6 +64,13 @@ pub struct WorkerConfig {
     /// `heartbeat_timeout * 0.8`.
     #[builder(default = "Duration::from_secs(30)")]
     pub default_heartbeat_throttle_interval: Duration,
+
+    /// Sets the maximum number of activities per second the task queue will dispatch, controlled
+    /// server-side. Note that this only takes effect upon an activity poll request. If multiple
+    /// workers on the same queue have different values set, they will thrash with the last poller
+    /// winning.
+    #[builder(setter(strip_option), default)]
+    pub max_task_queue_activities_per_second: Option<f64>,
 }
 
 impl WorkerConfig {