Skip to main content

How to set WorkerOptions in Go

Create an instance of Options from the go.temporal.io/sdk/worker package, set any of the optional fields, and pass the instance to the New call.

FieldRequiredType
MaxConcurrentActivityExecutionSizeNoint
WorkerActivitiesPerSecondNofloat64
MaxConcurrentLocalActivityExecutionSizeNoint
WorkerLocalActivitiesPerSecondNofloat64
TaskQueueActivitiesPerSecondNofloat64
MaxConcurrentActivityTaskPollersNoint
MaxConcurrentWorkflowTaskExecutionSizeNoint
MaxConcurrentWorkflowTaskPollersNoint
EnableLoggingInReplayNobool
DisableStickyExecutionNobool
StickyScheduleToStartTimeoutNotime.Duration
BackgroundActivityContextNocontext.Context
WorkflowPanicPolicyNoWorkflowPanicPolicy
WorkerStopTimeoutNotime.Duration
EnableSessionWorkerNobool
MaxConcurrentSessionExecutionSizeNoint
WorkflowInterceptorChainFactoriesNo[]WorkflowInterceptor
LocalActivityWorkerOnlyNobool
IdentityNostring
DeadlockDetectionTimeoutNotime.Duration

MaxConcurrentActivityExecutionSize#

Sets the the maximum concurrent Activity Executions for the Worker.

  • Type: int
  • Default: 1000

A value of 0 sets to the default.

// ...workerOptions := worker.Options{  MaxConcurrentActivityExecutionSize: 1000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

WorkerActivitiesPerSecond#

Rate limits the number of Activity Task Executions per second for the Worker.

  • Type: float64
  • Default: 100000

A value of 0 sets to the default.

Intended use case is to limit resources used by the Worker.

Notice that the value type is a float so that the value can be less than 1 if needed. For example, if set to 0.1, Activity Task Executions will happen once every ten seconds. This can be used to protect down stream services from flooding with requests.

// ...workerOptions := worker.Options{    WorkerActivitiesPerSecond: 100000,  // ..}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

MaxConcurrentLocalActivityExecutionSize#

Set the maximum concurrent Local Activity Executions for the Worker.

  • Type: int
  • Default: 1000

A value of 0 sets to the default value.

// ...workerOptions := worker.Options{    MaxConcurrentLocalActivityExecutionSize: 1000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

WorkerLocalActivitiesPerSecond#

Rate limits the number of Local Activity Executions per second executed for the Worker.

  • Type: float64
  • Default: 100000

A value of 0 sets to the default value.

Intended use case is to limit resources used by the Worker.

Notice that the value type is a float so that the value can be less than 1 if needed. For example, if set to 0.1, Local Activity Task Executions will happen once every ten seconds. This can be used to protect down stream services from flooding with requests.

// ...workerOptions := worker.Options{    WorkerLocalActivitiesPerSecond: 100000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

TaskQueueActivitiesPerSecond#

Rate limits the number of Activity Executions that can be executed per second

  • Type: float64
  • Default: 100000

A value of 0 sets to the default value.

This rate is managed by the Temporal Cluster and limits the Activity Tasks per second for the entire Task Queue. This is in contrast to WorkerActivityTasksPerSecond controls activities only per worker.

Notice that the number is represented in float, so that you can set it to less than 1 if needed. For example, set the number to 0.1 means you want your activity to be executed once for every 10 seconds. This can be used to protect down stream services from flooding.

// ...workerOptions := worker.Options{    TaskQueueActivitiesPerSecond: 100000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

MaxConcurrentActivityTaskPollers#

Sets the maximum number of goroutines to concurrently poll the Task Queue for Activity Tasks.

  • Type: int
  • Default: 2

Changing this value will affect the rate at which the Worker is able to consume Activity Tasks from the Task Queue.

// ...workerOptions := worker.Options{    MaxConcurrentActivityTaskPollers: 2,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

MaxConcurrentWorkflowTaskExecutionSize#

Sets the maximum number of concurrent Workflow Task Executions the Worker can have.

  • Type: int
  • Default: 1000

A value of 0 sets to the default value.

// ...workerOptions := worker.Options{    MaxConcurrentWorkflowTaskExecutionSize: 1000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

MaxConcurrentWorkflowTaskPollers#

Sets the maximum number of goroutines that will concurrently poll the Task Queue for Workflow Tasks.

  • Type: int
  • Default: 2

Changing this value will affect the rate at which the Worker is able to consume Workflow Tasks from the Task Queue.

// ...workerOptions := worker.Options{    MaxConcurrentWorkflowTaskPollers: 2,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

EnableLoggingInReplay#

Set to enable logging in Workflow Execution replays.

  • type: bool
  • Default: false

In Workflow Definitions you can use workflow.GetLogger(ctx) to write logs. By default, the logger will skip logging during replays so you do not see duplicate logs.

This is only really useful for debugging purpose.

// ...workerOptions := worker.Options{    EnableLoggingInReplay: false,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

DisableStickyExecution#

Deprecated

When DisableStickyExecution is true it can harm performance. It will be removed soon. See SetStickyWorkflowCacheSize instead.

Set to disable Sticky Executions

  • Type: bool
  • Default: false

Sticky Execution runs Workflow Tasks of a Workflow Execution on same host (could be a different Worker, as long as it is on the same host). This is an optimization for Workflow Executions. When sticky execution is enabled, worker keeps the workflow state in memory. New workflow task contains the new history events will be dispatched to the same worker. If this worker crashes, the sticky workflow task will timeout after StickyScheduleToStartTimeout, and temporal server will clear the stickiness for that workflow execution and automatically reschedule a new workflow task that is available for any worker to pick up and resume the progress.

// ...workerOptions := worker.Options{    DisableStickyExecution: false,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

StickyScheduleToStartTimeout#

Sets the Sticky Execution Schedule-To-Start Timeout for Workflow Tasks.

The resolution is in seconds.

// ...workerOptions := worker.Options{    DisableStickyExecution: false,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

BackgroundActivityContext#

Not recommended

This method of passing dependencies between Activity Task Executions is not recommended anymore.

Instead, we recommend using a struct with fields that contain dependencies and develop Activity Definitions as struct methods and then pass all the dependencies on the structure initialization.

Sets the background context.Context for all Activity Types registered with the Worker.

The context can be used to pass external dependencies such as database connections to Activity Task Executions.

// ...ctx := context.WithValue(context.Background(), "your-key", "your-value")workerOptions := worker.Options{    BackgroundActivityContext: ctx,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

WorkflowPanicPolicy#

Sets how the Workflow Worker handles a non-deterministic Workflow Execution History Event and other panics from Workflow Definition code.

// ...workerOptions := worker.Options{    DisableStickyExecution: internal.BlockWorkflow,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

WorkerStopTimeout#

Sets the Worker's graceful stop timeout

Value resolution is in seconds.

// ...workerOptions := worker.Options{    WorkerStopTimeout: time.Second(0),  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

EnableSessionWorker#

Enables Sessions for Activity Workers.

  • Type: bool
  • Default: false

When true the Activity Worker create a Session to sequentially process Activity Tasks for the given Task Queue.

// ...workerOptions := worker.Options{    EnableSessionWorker: true,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

MaxConcurrentSessionExecutionSize#

Sets the maximum number of concurrent Sessions that the Worker can support.

  • Type: int
  • Default: 1000
// ...workerOptions := worker.Options{    MaxConcurrentSessionExecutionSize: 1000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

WorkflowInterceptorChainFactories#

Specifies the factories used to instantiate the Workflow interceptor chain.

The chain is instantiated for each replay of a Workflow Execution.

LocalActivityWorkerOnly#

Sets the Worker to only handle Workflow Tasks and local Activity Tasks.

  • Type: bool
  • Default: false
// ...workerOptions := worker.Options{    LocalActivityWorkerOnly: 1000,  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

Identity#

Sets the Temporal Client-level Identity value, overwriting the existing one.

  • Type: string
  • Default: client identity
// ...workerOptions := worker.Options{    Identity: "your_custom_identity",  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

DeadlockDetectionTimeout#

Sets the maximum time that a Workflow Task can execute for.

Resolution is in seconds.

// ...workerOptions := worker.Options{    DeadlockDetectionTimeout: time.Second(1),  // ...}w := worker.New(c, "your_task_queue_name", workerOptions)// ...

Get notified of updates