#345

Committed 24 Jul 2026 11:20PM UTC coverage: 68.152%. First build

Build # #345

Build Type

push

github

Committed by

web-flow

Commit Message

Make eager activity reservation limit configurable (#2970)

Coverage Stats

7064 of 12428 branches covered (56.84%)

Branch coverage included in aggregate %.

14 of 15 new or added lines in 4 files covered. (93.33%)

29361 of 41019 relevant lines covered (71.58%)

0.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.23

/temporal-sdk/src/main/java/io/temporal/worker/WorkerOptions.java

package io.temporal.worker;

import static java.lang.Double.compare;

import com.google.common.base.Preconditions;
import io.temporal.common.Experimental;
import io.temporal.internal.Config;
import io.temporal.serviceclient.WorkflowServiceStubsOptions;
import io.temporal.worker.tuning.*;
import java.time.Duration;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public final class WorkerOptions {

  public static Builder newBuilder() {
    return new Builder();
  }

  public static Builder newBuilder(WorkerOptions options) {
    return new Builder(options);
  }

  public static WorkerOptions getDefaultInstance() {
    return DEFAULT_INSTANCE;
  }

  static final Duration DEFAULT_STICKY_SCHEDULE_TO_START_TIMEOUT = Duration.ofSeconds(5);

  static final Duration DEFAULT_STICKY_TASK_QUEUE_DRAIN_TIMEOUT = Duration.ofSeconds(0);

  private static final WorkerOptions DEFAULT_INSTANCE;

  static {
    DEFAULT_INSTANCE = WorkerOptions.newBuilder().validateAndBuildWithDefaults();
  }

  public static final class Builder {

    private static final int DEFAULT_MAX_CONCURRENT_WORKFLOW_TASK_POLLERS = 5;
    private static final int DEFAULT_MAX_CONCURRENT_ACTIVITY_TASK_POLLERS = 5;
    private static final int DEFAULT_MAX_CONCURRENT_NEXUS_TASK_POLLERS = 5;
    private static final int DEFAULT_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTION_SIZE = 200;
    private static final int DEFAULT_MAX_CONCURRENT_ACTIVITY_EXECUTION_SIZE = 200;
    private static final int DEFAULT_MAX_CONCURRENT_LOCAL_ACTIVITY_EXECUTION_SIZE = 200;
    private static final int DEFAULT_MAX_CONCURRENT_NEXUS_EXECUTION_SIZE = 200;
    private static final long DEFAULT_DEADLOCK_DETECTION_TIMEOUT = 1000;
    private static final Duration DEFAULT_MAX_HEARTBEAT_THROTTLE_INTERVAL = Duration.ofSeconds(60);
    private static final Duration DEFAULT_DEFAULT_HEARTBEAT_THROTTLE_INTERVAL =
        Duration.ofSeconds(30);

    private double maxWorkerActivitiesPerSecond;
    private int maxConcurrentActivityExecutionSize;
    private int maxConcurrentWorkflowTaskExecutionSize;
    private int maxConcurrentLocalActivityExecutionSize;
    private int maxConcurrentNexusExecutionSize;
    private double maxTaskQueueActivitiesPerSecond;
    private int maxConcurrentWorkflowTaskPollers;
    private int maxConcurrentActivityTaskPollers;
    private int maxConcurrentNexusTaskPollers;
    private boolean localActivityWorkerOnly;
    private long defaultDeadlockDetectionTimeout;
    private Duration maxHeartbeatThrottleInterval;
    private Duration defaultHeartbeatThrottleInterval;
    private Duration stickyQueueScheduleToStartTimeout;
    private boolean disableEagerExecution;
    private int maxEagerActivityReservationsPerWorkflowTask = Config.EAGER_ACTIVITIES_LIMIT;
    private String buildId;
    private boolean useBuildIdForVersioning;
    private Duration stickyTaskQueueDrainTimeout;
    private WorkerTuner workerTuner;
    private boolean usingVirtualThreadsOnWorkflowWorker;
    private boolean usingVirtualThreadsOnActivityWorker;
    private boolean usingVirtualThreadsOnLocalActivityWorker;
    private boolean usingVirtualThreadsOnNexusWorker;
    private String identity;
    private WorkerDeploymentOptions deploymentOptions;
    private PollerBehavior workflowTaskPollersBehavior;
    private PollerBehavior activityTaskPollersBehavior;
    private PollerBehavior nexusTaskPollersBehavior;
    private boolean allowActivityHeartbeatDuringShutdown;
    private PreferredVersionProvider preferredVersionProvider;
    // Track whether the user explicitly configured the pollers for a task type (called either the
    // max-concurrent-pollers or the poller-behavior setter). A type left unconfigured is eligible
    // for poller-autoscaling auto-enrollment. This must reflect the user's intent, not the resolved
    // value, since defaulting fills in a non-zero count that would otherwise look explicit.
    private boolean workflowTaskPollersConfigured;
    private boolean activityTaskPollersConfigured;
    private boolean nexusTaskPollersConfigured;

    private Builder() {}

    private Builder(WorkerOptions o) {
      if (o == null) {
        return;
      }
      this.maxWorkerActivitiesPerSecond = o.maxWorkerActivitiesPerSecond;
      this.maxConcurrentActivityExecutionSize = o.maxConcurrentActivityExecutionSize;
      this.maxConcurrentWorkflowTaskExecutionSize = o.maxConcurrentWorkflowTaskExecutionSize;
      this.maxConcurrentLocalActivityExecutionSize = o.maxConcurrentLocalActivityExecutionSize;
      this.maxConcurrentNexusExecutionSize = o.maxConcurrentNexusExecutionSize;
      this.workerTuner = o.workerTuner;
      this.maxTaskQueueActivitiesPerSecond = o.maxTaskQueueActivitiesPerSecond;
      this.maxConcurrentWorkflowTaskPollers = o.maxConcurrentWorkflowTaskPollers;
      this.maxConcurrentNexusTaskPollers = o.maxConcurrentNexusTaskPollers;
      this.maxConcurrentActivityTaskPollers = o.maxConcurrentActivityTaskPollers;
      this.localActivityWorkerOnly = o.localActivityWorkerOnly;
      this.defaultDeadlockDetectionTimeout = o.defaultDeadlockDetectionTimeout;
      this.maxHeartbeatThrottleInterval = o.maxHeartbeatThrottleInterval;
      this.defaultHeartbeatThrottleInterval = o.defaultHeartbeatThrottleInterval;
      this.stickyQueueScheduleToStartTimeout = o.stickyQueueScheduleToStartTimeout;
      this.disableEagerExecution = o.disableEagerExecution;
      this.maxEagerActivityReservationsPerWorkflowTask =
          o.maxEagerActivityReservationsPerWorkflowTask;
      this.useBuildIdForVersioning = o.useBuildIdForVersioning;
      this.buildId = o.buildId;
      this.stickyTaskQueueDrainTimeout = o.stickyTaskQueueDrainTimeout;
      this.identity = o.identity;
      this.usingVirtualThreadsOnActivityWorker = o.usingVirtualThreadsOnActivityWorker;
      this.usingVirtualThreadsOnWorkflowWorker = o.usingVirtualThreadsOnWorkflowWorker;
      this.usingVirtualThreadsOnLocalActivityWorker = o.usingVirtualThreadsOnLocalActivityWorker;
      this.usingVirtualThreadsOnNexusWorker = o.usingVirtualThreadsOnNexusWorker;
      this.deploymentOptions = o.deploymentOptions;
      this.workflowTaskPollersBehavior = o.workflowTaskPollersBehavior;
      this.activityTaskPollersBehavior = o.activityTaskPollersBehavior;
      this.nexusTaskPollersBehavior = o.nexusTaskPollersBehavior;
      this.allowActivityHeartbeatDuringShutdown = o.allowActivityHeartbeatDuringShutdown;
      this.preferredVersionProvider = o.preferredVersionProvider;
      this.workflowTaskPollersConfigured = o.workflowTaskPollersConfigured;
      this.activityTaskPollersConfigured = o.activityTaskPollersConfigured;
      this.nexusTaskPollersConfigured = o.nexusTaskPollersConfigured;
    }

    /**
     * @param maxWorkerActivitiesPerSecond Maximum number of activities started per second by this
     *     worker. Default is 0 which means unlimited.
     * @return {@code this}
     *     <p>If worker is not fully loaded while tasks are backing up on the service consider
     *     increasing {@link #setMaxConcurrentActivityTaskPollers(int)}.
     *     <p>Note that this is a per worker limit. Use {@link
     *     #setMaxTaskQueueActivitiesPerSecond(double)} to set per task queue limit across multiple
     *     workers.
     */
    public Builder setMaxWorkerActivitiesPerSecond(double maxWorkerActivitiesPerSecond) {
      if (maxWorkerActivitiesPerSecond < 0) {
        throw new IllegalArgumentException(
            "Negative maxWorkerActivitiesPerSecond value: " + maxWorkerActivitiesPerSecond);
      }
      this.maxWorkerActivitiesPerSecond = maxWorkerActivitiesPerSecond;
      return this;
    }

    /**
     * @param maxConcurrentActivityExecutionSize Maximum number of activities executed in parallel.
     *     Default is 200, which is chosen if set to zero.
     * @return {@code this}
     *     <p>Note setting is mutually exclusive with {@link #setWorkerTuner(WorkerTuner)}
     */
    public Builder setMaxConcurrentActivityExecutionSize(int maxConcurrentActivityExecutionSize) {
      if (maxConcurrentActivityExecutionSize < 0) {
        throw new IllegalArgumentException(
            "Negative maxConcurrentActivityExecutionSize value: "
                + maxConcurrentActivityExecutionSize);
      }
      this.maxConcurrentActivityExecutionSize = maxConcurrentActivityExecutionSize;
      return this;
    }

    /**
     * @param maxConcurrentWorkflowTaskExecutionSize Maximum number of simultaneously executed
     *     workflow tasks. Default is 200, which is chosen if set to zero.
     * @return {@code this}
     *     <p>Note that this is not related to the total number of open workflows which do not need
     *     to be loaded in a worker when they are not making state transitions.
     *     <p>Note setting is mutually exclusive with {@link #setWorkerTuner(WorkerTuner)}
     */
    public Builder setMaxConcurrentWorkflowTaskExecutionSize(
        int maxConcurrentWorkflowTaskExecutionSize) {
      if (maxConcurrentWorkflowTaskExecutionSize < 0) {
        throw new IllegalArgumentException(
            "Negative maxConcurrentWorkflowTaskExecutionSize value: "
                + maxConcurrentWorkflowTaskExecutionSize);
      }
      this.maxConcurrentWorkflowTaskExecutionSize = maxConcurrentWorkflowTaskExecutionSize;
      return this;
    }

    /**
     * @param maxConcurrentLocalActivityExecutionSize Maximum number of local activities executed in
     *     parallel. Default is 200, which is chosen if set to zero.
     * @return {@code this}
     *     <p>Note setting is mutually exclusive with {@link #setWorkerTuner(WorkerTuner)}
     */
    public Builder setMaxConcurrentLocalActivityExecutionSize(
        int maxConcurrentLocalActivityExecutionSize) {
      if (maxConcurrentLocalActivityExecutionSize < 0) {
        throw new IllegalArgumentException(
            "Negative maxConcurrentLocalActivityExecutionSize value: "
                + maxConcurrentLocalActivityExecutionSize);
      }
      this.maxConcurrentLocalActivityExecutionSize = maxConcurrentLocalActivityExecutionSize;
      return this;
    }

    /**
     * @param maxConcurrentNexusExecutionSize Maximum number of nexus tasks executed in parallel.
     *     Default is 200, which is chosen if set to zero.
     * @return {@code this}
     *     <p>Note setting is mutually exclusive with {@link #setWorkerTuner(WorkerTuner)}
     */
    @Experimental
    public Builder setMaxConcurrentNexusExecutionSize(int maxConcurrentNexusExecutionSize) {
      if (maxConcurrentNexusExecutionSize < 0) {
        throw new IllegalArgumentException(
            "Negative maxConcurrentNexusExecutionSize value: " + maxConcurrentNexusExecutionSize);
      }
      this.maxConcurrentNexusExecutionSize = maxConcurrentNexusExecutionSize;
      return this;
    }

    /**
     * Optional: Sets the rate limiting on number of activities that can be executed per second.
     * This is managed by the server and controls activities per second for the entire task queue
     * across all the workers. Notice that the number is represented in double, 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 every 10 seconds. This can be used to protect down stream services from
     * flooding. The zero value of this uses the default value. Default is unlimited.
     *
     * <p>Setting this value to a non-zero value will disable eager execution for activities.
     */
    public Builder setMaxTaskQueueActivitiesPerSecond(double maxTaskQueueActivitiesPerSecond) {
      this.maxTaskQueueActivitiesPerSecond = maxTaskQueueActivitiesPerSecond;
      return this;
    }

    /**
     * Sets the maximum number of simultaneous long poll requests to the Temporal Server to retrieve
     * workflow tasks. Changing this value will affect the rate at which the worker is able to
     * consume tasks from a task queue.
     *
     * <p>Due to internal logic where pollers alternate between sticky and non-sticky queues, this
     * value cannot be 1 and will be adjusted to 2 if set to that value.
     *
     * <p>Default is 5, which is chosen if set to zero.
     *
     * <p>NOTE: If neither this nor {@link #setWorkflowTaskPollersBehavior} is set and the worker's
     * namespace is configured to auto-enroll workers into poller autoscaling, the worker will
     * automatically use poller autoscaling for workflow tasks instead of a fixed number of pollers.
     */
    public Builder setMaxConcurrentWorkflowTaskPollers(int maxConcurrentWorkflowTaskPollers) {
      this.maxConcurrentWorkflowTaskPollers = maxConcurrentWorkflowTaskPollers;
      this.workflowTaskPollersConfigured = true;
      return this;
    }

    /**
     * Sets the maximum number of simultaneous long poll requests to the Temporal Server to retrieve
     * nexus tasks. Changing this value will affect the rate at which the worker is able to consume
     * tasks from a task queue.
     *
     * <p>Default is 5, which is chosen if set to zero.
     *
     * <p>NOTE: If neither this nor {@link #setNexusTaskPollersBehavior} is set and the worker's
     * namespace is configured to auto-enroll workers into poller autoscaling, the worker will
     * automatically use poller autoscaling for nexus tasks instead of a fixed number of pollers.
     */
    @Experimental
    public Builder setMaxConcurrentNexusTaskPollers(int maxConcurrentNexusTaskPollers) {
      this.maxConcurrentNexusTaskPollers = maxConcurrentNexusTaskPollers;
      this.nexusTaskPollersConfigured = true;
      return this;
    }

    /**
     * Number of simultaneous poll requests on workflow task queue. Note that the majority of the
     * workflow tasks will be using host local task queue due to caching. So try incrementing {@link
     * WorkerFactoryOptions.Builder#setWorkflowHostLocalPollThreadCount(int)} before this one.
     *
     * <p>Default is 5, which is chosen if set to zero.
     *
     * @deprecated Use {@link #setMaxConcurrentWorkflowTaskPollers}
     */
    @Deprecated
    public Builder setWorkflowPollThreadCount(int workflowPollThreadCount) {
      return setMaxConcurrentWorkflowTaskPollers(workflowPollThreadCount);
    }

    /**
     * Number of simultaneous poll requests on activity task queue. Consider incrementing if the
     * worker is not throttled due to `MaxActivitiesPerSecond` or
     * `MaxConcurrentActivityExecutionSize` options and still cannot keep up with the request rate.
     *
     * <p>Default is 5, which is chosen if set to zero.
     *
     * <p>NOTE: If neither this nor {@link #setActivityTaskPollersBehavior} is set and the worker's
     * namespace is configured to auto-enroll workers into poller autoscaling, the worker will
     * automatically use poller autoscaling for activity tasks instead of a fixed number of pollers.
     */
    public Builder setMaxConcurrentActivityTaskPollers(int maxConcurrentActivityTaskPollers) {
      this.maxConcurrentActivityTaskPollers = maxConcurrentActivityTaskPollers;
      this.activityTaskPollersConfigured = true;
      return this;
    }

    /**
     * Number of simultaneous poll requests on activity task queue. Consider incrementing if the
     * worker is not throttled due to `MaxActivitiesPerSecond` or
     * `MaxConcurrentActivityExecutionSize` options and still cannot keep up with the request rate.
     *
     * <p>Default is 5, which is chosen if set to zero.
     *
     * @deprecated Use {@link #setMaxConcurrentActivityTaskPollers}
     */
    @Deprecated
    public Builder setActivityPollThreadCount(int activityPollThreadCount) {
      return setMaxConcurrentActivityTaskPollers(activityPollThreadCount);
    }

    /**
     * If set to true worker would only handle workflow tasks and local activities. Non-local
     * activities will not be executed by this worker.
     *
     * <p>Default is false.
     */
    public Builder setLocalActivityWorkerOnly(boolean localActivityWorkerOnly) {
      this.localActivityWorkerOnly = localActivityWorkerOnly;
      return this;
    }

    /**
     * @param defaultDeadlockDetectionTimeoutMs time period in ms that will be used to detect
     *     workflows deadlock. Default is 1000ms, which is chosen if set to zero.
     *     <p>Specifies a time interval in milliseconds within which a workflow task must yield
     *     (like calling an Activity) or complete. If a workflow task runs longer than the specified
     *     interval or takes too long to begin running, it will fail automatically.
     * @return {@code this}
     * @see io.temporal.internal.sync.PotentialDeadlockException
     */
    public Builder setDefaultDeadlockDetectionTimeout(long defaultDeadlockDetectionTimeoutMs) {
      if (defaultDeadlockDetectionTimeoutMs < 0) {
        throw new IllegalArgumentException(
            "Negative defaultDeadlockDetectionTimeout value: " + defaultDeadlockDetectionTimeoutMs);
      }
      this.defaultDeadlockDetectionTimeout = defaultDeadlockDetectionTimeoutMs;
      return this;
    }

    /**
     * @param interval the maximum amount of time between sending each pending heartbeat to the
     *     server. Regardless of heartbeat timeout, no pending heartbeat will wait longer than this
     *     amount of time to send. Default is 60s, which is chosen if set to null or 0.
     * @return {@code this}
     */
    public Builder setMaxHeartbeatThrottleInterval(@Nullable Duration interval) {
      Preconditions.checkArgument(
          interval == null || !interval.isNegative(),
          "Negative maxHeartbeatThrottleInterval value: %s",
          interval);
      this.maxHeartbeatThrottleInterval = interval;
      return this;
    }

    /**
     * @param interval the default amount of time between sending each pending heartbeat to the
     *     server. This is used if the ActivityOptions do not provide a HeartbeatTimeout. Otherwise,
     *     the interval becomes a value a bit smaller than the given HeartbeatTimeout. Default is
     *     30s, which is chosen if set to null or 0.
     * @return {@code this}
     */
    public Builder setDefaultHeartbeatThrottleInterval(@Nullable Duration interval) {
      Preconditions.checkArgument(
          interval == null || !interval.isNegative(),
          "Negative defaultHeartbeatThrottleInterval value: %s",
          interval);
      this.defaultHeartbeatThrottleInterval = interval;
      return this;
    }

    /**
     * Timeout for a workflow task routed to the "sticky worker" - host that has the workflow
     * instance cached in memory. Once it times out, then it can be picked up by any worker.
     *
     * <p>Default value is 5 seconds.
     */
    public Builder setStickyQueueScheduleToStartTimeout(Duration timeout) {
      this.stickyQueueScheduleToStartTimeout = timeout;
      return this;
    }

    /**
     * Disable eager activities. If set to true, eager execution will not be requested for
     * activities requested from workflows bound to this Worker.
     *
     * <p>Eager activity execution means the server returns requested eager activities directly from
     * the workflow task back to this worker which is faster than non-eager which may be dispatched
     * to a separate worker.
     *
     * <p>Defaults to false, meaning that eager activity execution is permitted. Unless you set
     * MaxTaskQueueActivitiesPerSecond, then eager execution is disabled.
     */
    public Builder setDisableEagerExecution(boolean disableEagerExecution) {
      this.disableEagerExecution = disableEagerExecution;
      return this;
    }

    /**
     * Sets the maximum number of activity slots that may be reserved for eager execution when
     * completing a workflow task.
     *
     * <p>The default is 3. The value must be positive. To disable eager activity execution, use
     * {@link #setDisableEagerExecution(boolean)}.
     */
    public Builder setMaxEagerActivityReservationsPerWorkflowTask(
        int maxEagerActivityReservationsPerWorkflowTask) {
      this.maxEagerActivityReservationsPerWorkflowTask =
          maxEagerActivityReservationsPerWorkflowTask;
      return this;
    }

    /**
     * Opts the worker in to the Build-ID-based versioning feature. This ensures that the worker
     * will only receive tasks which it is compatible with.
     *
     * <p>Defaults to false
     *
     * @deprecated Worker Versioning is now deprecated please migrate to the <a
     *     href="https://docs.temporal.io/worker-deployments">Worker Deployment API</a>.
     */
    @Experimental
    @Deprecated
    public Builder setUseBuildIdForVersioning(boolean useBuildIdForVersioning) {
      this.useBuildIdForVersioning = useBuildIdForVersioning;
      return this;
    }

    /**
     * Set a unique identifier for this worker. The identifier should be stable with respect to the
     * code the worker uses for workflows, activities, and interceptors.
     *
     * <p>A Build Id must be set if {@link #setUseBuildIdForVersioning(boolean)} is set true.
     *
     * @deprecated Worker Versioning is now deprecated please migrate to the <a
     *     href="https://docs.temporal.io/worker-deployments">Worker Deployment API</a>.
     */
    @Experimental
    @Deprecated
    public Builder setBuildId(String buildId) {
      this.buildId = buildId;
      return this;
    }

    /**
     * During graceful shutdown, as when calling {@link WorkerFactory#shutdown()}, if the workflow
     * cache is enabled, this timeout controls how long to wait for the sticky task queue to drain
     * before shutting down the worker. If set the worker will stop making new poll requests on the
     * normal task queue, but will continue to poll the sticky task queue until the timeout is
     * reached. This value should always be greater than clients rpc long poll timeout, which can be
     * set via {@link WorkflowServiceStubsOptions.Builder#setRpcLongPollTimeout(Duration)}.
     *
     * <p>Default is not to wait.
     */
    @Experimental
    public Builder setStickyTaskQueueDrainTimeout(Duration stickyTaskQueueDrainTimeout) {
      this.stickyTaskQueueDrainTimeout = stickyTaskQueueDrainTimeout;
      return this;
    }

    /**
     * Set a {@link WorkerTuner} to determine how slots will be allocated for different types of
     * tasks.
     */
    public Builder setWorkerTuner(WorkerTuner workerTuner) {
      this.workerTuner = workerTuner;
      return this;
    }

    /**
     * Use Virtual Threads for all the task executors created by this worker. This option is only
     * supported for JDK >= 21. Individual options for different types of workers can be set using
     * the respective methods.
     */
    public Builder setUsingVirtualThreads(boolean enable) {
      this.usingVirtualThreadsOnWorkflowWorker = enable;
      this.usingVirtualThreadsOnLocalActivityWorker = enable;
      this.usingVirtualThreadsOnActivityWorker = enable;
      this.usingVirtualThreadsOnNexusWorker = enable;
      return this;
    }

    /**
     * Use Virtual Threads for the Workflow task executors created by this worker. This option is
     * only supported for JDK >= 21.
     */
    public Builder setUsingVirtualThreadsOnWorkflowWorker(boolean enable) {
      this.usingVirtualThreadsOnWorkflowWorker = enable;
      return this;
    }

    /**
     * Use Virtual Threads for the Local Activity task executors created by this worker. This option
     * is only supported for JDK >= 21.
     */
    public Builder setUsingVirtualThreadsOnLocalActivityWorker(boolean enable) {
      this.usingVirtualThreadsOnLocalActivityWorker = enable;
      return this;
    }

    /**
     * Use Virtual Threads for the Activity task executors created by this worker. This option is
     * only supported for JDK >= 21.
     */
    public Builder setUsingVirtualThreadsOnActivityWorker(boolean enable) {
      this.usingVirtualThreadsOnActivityWorker = enable;
      return this;
    }

    /**
     * Use Virtual Threads for the Nexus task executors created by this worker. This option is only
     * supported for JDK >= 21.
     */
    public Builder setUsingVirtualThreadsOnNexusWorker(boolean enable) {
      this.usingVirtualThreadsOnNexusWorker = enable;
      return this;
    }

    /** Override identity of the worker primary specified in a WorkflowClient options. */
    public Builder setIdentity(String identity) {
      this.identity = identity;
      return this;
    }

    /**
     * Set deployment options for the worker. Exclusive with {@link #setUseBuildIdForVersioning} and
     * {@link #setBuildId(String)}.
     */
    public Builder setDeploymentOptions(WorkerDeploymentOptions deploymentOptions) {
      this.deploymentOptions = deploymentOptions;
      return this;
    }

    /**
     * Set the poller behavior for workflow task pollers.
     *
     * <p>Note: If the poller behavior is set to {@link PollerBehaviorSimpleMaximum}, the maximum
     * number of concurrent workflow task pollers must be at least 2 to account for the sticky and
     * non-sticky task poller. If it is set to 1 it will be automatically adjusted to 2.
     *
     * <p>If the sticky queue is enabled, the poller behavior will be used for the sticky queue as
     * well.
     *
     * <p>NOTE: If neither this nor {@link #setMaxConcurrentWorkflowTaskPollers} is set and the
     * worker's namespace is configured to auto-enroll workers into poller autoscaling, the worker
     * will automatically use poller autoscaling for workflow tasks instead of a fixed number of
     * pollers.
     */
    public Builder setWorkflowTaskPollersBehavior(PollerBehavior pollerBehavior) {
      this.workflowTaskPollersBehavior = pollerBehavior;
      this.workflowTaskPollersConfigured = true;
      return this;
    }

    /**
     * Set the poller behavior for activity task pollers.
     *
     * <p>NOTE: If neither this nor {@link #setMaxConcurrentActivityTaskPollers} is set and the
     * worker's namespace is configured to auto-enroll workers into poller autoscaling, the worker
     * will automatically use poller autoscaling for activity tasks instead of a fixed number of
     * pollers.
     */
    public Builder setActivityTaskPollersBehavior(PollerBehavior pollerBehavior) {
      this.activityTaskPollersBehavior = pollerBehavior;
      this.activityTaskPollersConfigured = true;
      return this;
    }

    /**
     * Set the poller behavior for nexus task pollers.
     *
     * <p>NOTE: If neither this nor {@link #setMaxConcurrentNexusTaskPollers} is set and the
     * worker's namespace is configured to auto-enroll workers into poller autoscaling, the worker
     * will automatically use poller autoscaling for nexus tasks instead of a fixed number of
     * pollers.
     */
    public Builder setNexusTaskPollersBehavior(PollerBehavior pollerBehavior) {
      this.nexusTaskPollersBehavior = pollerBehavior;
      this.nexusTaskPollersConfigured = true;
      return this;
    }

    /**
     * If true, activities can keep heartbeating during graceful worker shutdown (see {@link
     * io.temporal.worker.WorkerFactory#shutdown WorkerFactory.shutdown}). Defaults to false, which
     * means that after graceful shutdown is requested, calling {@link
     * io.temporal.activity.ActivityExecutionContext#heartbeat ActivityExecutionContext.heartbeat}
     * does not send a heartbeat and instead throws {@link
     * io.temporal.client.ActivityWorkerShutdownException ActivityWorkerShutdownException}. This
     * option is ignored by non-graceful shutdown (see {@link
     * io.temporal.worker.WorkerFactory#shutdownNow WorkerFactory.shutdownNow}).
     *
     * <p>Note that with this option enabled, activities are no longer notified of the worker
     * shutdown by the {@link io.temporal.client.ActivityWorkerShutdownException
     * ActivityWorkerShutdownException} exception, so they are expected to complete within the
     * termination grace period on their own.
     */
    @Experimental
    public Builder setAllowActivityHeartbeatDuringShutdown(
        boolean allowActivityHeartbeatDuringShutdown) {
      this.allowActivityHeartbeatDuringShutdown = allowActivityHeartbeatDuringShutdown;
      return this;
    }

    /**
     * Sets a provider that can choose the version recorded by the first non-replay {@link
     * io.temporal.workflow.Workflow#getVersion(String, int, int)} call for a change ID.
     *
     * <p>If unset, or if the provider returns {@link java.util.Optional#empty()}, the SDK keeps the
     * existing behavior of recording {@code maxSupported}.
     */
    @Experimental
    public Builder setPreferredVersionProvider(PreferredVersionProvider preferredVersionProvider) {
      this.preferredVersionProvider = preferredVersionProvider;
      return this;
    }

    public WorkerOptions build() {
      return new WorkerOptions(
          maxWorkerActivitiesPerSecond,
          maxConcurrentActivityExecutionSize,
          maxConcurrentWorkflowTaskExecutionSize,
          maxConcurrentLocalActivityExecutionSize,
          maxConcurrentNexusExecutionSize,
          workerTuner,
          maxTaskQueueActivitiesPerSecond,
          maxConcurrentWorkflowTaskPollers,
          maxConcurrentActivityTaskPollers,
          maxConcurrentNexusTaskPollers,
          localActivityWorkerOnly,
          defaultDeadlockDetectionTimeout,
          maxHeartbeatThrottleInterval,
          defaultHeartbeatThrottleInterval,
          stickyQueueScheduleToStartTimeout,
          disableEagerExecution,
          maxEagerActivityReservationsPerWorkflowTask,
          useBuildIdForVersioning,
          buildId,
          stickyTaskQueueDrainTimeout,
          identity,
          usingVirtualThreadsOnWorkflowWorker,
          usingVirtualThreadsOnActivityWorker,
          usingVirtualThreadsOnLocalActivityWorker,
          usingVirtualThreadsOnNexusWorker,
          deploymentOptions,
          workflowTaskPollersBehavior,
          activityTaskPollersBehavior,
          nexusTaskPollersBehavior,
          allowActivityHeartbeatDuringShutdown,
          preferredVersionProvider,
          workflowTaskPollersConfigured,
          activityTaskPollersConfigured,
          nexusTaskPollersConfigured);
    }

    public WorkerOptions validateAndBuildWithDefaults() {
      Preconditions.checkState(
          maxWorkerActivitiesPerSecond >= 0, "negative maxActivitiesPerSecond");
      Preconditions.checkState(
          maxConcurrentActivityExecutionSize >= 0, "negative maxConcurrentActivityExecutionSize");
      Preconditions.checkState(
          maxEagerActivityReservationsPerWorkflowTask > 0,
          "maxEagerActivityReservationsPerWorkflowTask must be positive; use "
              + "setDisableEagerExecution(true) to disable eager activity execution");
      Preconditions.checkState(
          maxConcurrentWorkflowTaskExecutionSize >= 0,
          "negative maxConcurrentWorkflowTaskExecutionSize");
      Preconditions.checkState(
          maxConcurrentLocalActivityExecutionSize >= 0,
          "negative maxConcurrentLocalActivityExecutionSize");
      if (workerTuner != null) {
        Preconditions.checkState(
            maxConcurrentActivityExecutionSize == 0,
            "maxConcurrentActivityExecutionSize must not be set if workerTuner is set");
      }
      if (workerTuner != null) {
        Preconditions.checkState(
            maxConcurrentWorkflowTaskExecutionSize == 0,
            "maxConcurrentWorkflowTaskExecutionSize must not be set if workerTuner is set");
      }
      if (workerTuner != null) {
        Preconditions.checkState(
            maxConcurrentLocalActivityExecutionSize == 0,
            "maxConcurrentLocalActivityExecutionSize must not be set if workerTuner is set");
      }
      Preconditions.checkState(
          maxTaskQueueActivitiesPerSecond >= 0, "negative taskQueueActivitiesPerSecond");
      Preconditions.checkState(
          maxConcurrentWorkflowTaskPollers >= 0, "negative maxConcurrentWorkflowTaskPollers");
      Preconditions.checkState(
          maxConcurrentActivityTaskPollers >= 0, "negative maxConcurrentActivityTaskPollers");
      Preconditions.checkState(
          defaultDeadlockDetectionTimeout >= 0, "negative defaultDeadlockDetectionTimeout");
      Preconditions.checkState(
          stickyQueueScheduleToStartTimeout == null
              || !stickyQueueScheduleToStartTimeout.isNegative(),
          "negative stickyQueueScheduleToStartTimeout");
      if (useBuildIdForVersioning) {
        Preconditions.checkState(
            buildId != null && !buildId.isEmpty(),
            "buildId must be set non-empty if useBuildIdForVersioning is set true");
        Preconditions.checkState(
            deploymentOptions == null,
            "deploymentOptions must not be set if useBuildIdForVersioning is set true");
      }
      if (buildId != null) {
        Preconditions.checkState(
            deploymentOptions == null,
            "deploymentOptions must not be set if buildId is set, prefer using deploymentOptions");
      }
      Preconditions.checkState(
          stickyTaskQueueDrainTimeout == null || !stickyTaskQueueDrainTimeout.isNegative(),
          "negative stickyTaskQueueDrainTimeout");
      Preconditions.checkState(
          maxConcurrentNexusTaskPollers >= 0, "negative maxConcurrentNexusTaskPollers");

      if (workflowTaskPollersBehavior != null) {
        Preconditions.checkState(
            maxConcurrentWorkflowTaskPollers == 0,
            "workflowTaskPollersBehavior and maxConcurrentWorkflowTaskPollers are mutually exclusive");
      }
      if (activityTaskPollersBehavior != null) {
        Preconditions.checkState(
            maxConcurrentActivityTaskPollers == 0,
            "activityTaskPollersBehavior and maxConcurrentActivityTaskPollers are mutually exclusive");
      }
      if (nexusTaskPollersBehavior != null) {
        Preconditions.checkState(
            maxConcurrentNexusTaskPollers == 0,
            "nexusTaskPollersBehavior and maxConcurrentNexusTaskPollers are mutually exclusive");
      }

      return new WorkerOptions(
          maxWorkerActivitiesPerSecond,
          maxConcurrentActivityExecutionSize == 0
              ? DEFAULT_MAX_CONCURRENT_ACTIVITY_EXECUTION_SIZE
              : maxConcurrentActivityExecutionSize,
          maxConcurrentWorkflowTaskExecutionSize == 0
              ? DEFAULT_MAX_CONCURRENT_WORKFLOW_TASK_EXECUTION_SIZE
              : maxConcurrentWorkflowTaskExecutionSize,
          maxConcurrentLocalActivityExecutionSize == 0
              ? DEFAULT_MAX_CONCURRENT_LOCAL_ACTIVITY_EXECUTION_SIZE
              : maxConcurrentLocalActivityExecutionSize,
          maxConcurrentNexusExecutionSize == 0
              ? DEFAULT_MAX_CONCURRENT_NEXUS_EXECUTION_SIZE
              : maxConcurrentNexusExecutionSize,
          workerTuner,
          maxTaskQueueActivitiesPerSecond,
          maxConcurrentWorkflowTaskPollers == 0
              ? (workflowTaskPollersBehavior != null
                  ? 0
                  : DEFAULT_MAX_CONCURRENT_WORKFLOW_TASK_POLLERS)
              : maxConcurrentWorkflowTaskPollers,
          maxConcurrentActivityTaskPollers == 0
              ? (activityTaskPollersBehavior != null
                  ? 0
                  : DEFAULT_MAX_CONCURRENT_ACTIVITY_TASK_POLLERS)
              : maxConcurrentActivityTaskPollers,
          maxConcurrentNexusTaskPollers == 0
              ? (nexusTaskPollersBehavior != null ? 0 : DEFAULT_MAX_CONCURRENT_NEXUS_TASK_POLLERS)
              : maxConcurrentNexusTaskPollers,
          localActivityWorkerOnly,
          defaultDeadlockDetectionTimeout == 0
              ? DEFAULT_DEADLOCK_DETECTION_TIMEOUT
              : defaultDeadlockDetectionTimeout,
          maxHeartbeatThrottleInterval == null || maxHeartbeatThrottleInterval.isZero()
              ? DEFAULT_MAX_HEARTBEAT_THROTTLE_INTERVAL
              : maxHeartbeatThrottleInterval,
          defaultHeartbeatThrottleInterval == null || defaultHeartbeatThrottleInterval.isZero()
              ? DEFAULT_DEFAULT_HEARTBEAT_THROTTLE_INTERVAL
              : defaultHeartbeatThrottleInterval,
          stickyQueueScheduleToStartTimeout == null
              ? DEFAULT_STICKY_SCHEDULE_TO_START_TIMEOUT
              : stickyQueueScheduleToStartTimeout,
          disableEagerExecution,
          maxEagerActivityReservationsPerWorkflowTask,
          useBuildIdForVersioning,
          buildId,
          stickyTaskQueueDrainTimeout == null
              ? DEFAULT_STICKY_TASK_QUEUE_DRAIN_TIMEOUT
              : stickyTaskQueueDrainTimeout,
          identity,
          usingVirtualThreadsOnWorkflowWorker,
          usingVirtualThreadsOnActivityWorker,
          usingVirtualThreadsOnLocalActivityWorker,
          usingVirtualThreadsOnNexusWorker,
          deploymentOptions,
          workflowTaskPollersBehavior,
          activityTaskPollersBehavior,
          nexusTaskPollersBehavior,
          allowActivityHeartbeatDuringShutdown,
          preferredVersionProvider,
          workflowTaskPollersConfigured,
          activityTaskPollersConfigured,
          nexusTaskPollersConfigured);
    }
  }

  private final double maxWorkerActivitiesPerSecond;
  private final int maxConcurrentActivityExecutionSize;
  private final int maxConcurrentWorkflowTaskExecutionSize;
  private final int maxConcurrentLocalActivityExecutionSize;
  private final int maxConcurrentNexusExecutionSize;
  private final WorkerTuner workerTuner;
  private final double maxTaskQueueActivitiesPerSecond;
  private final int maxConcurrentWorkflowTaskPollers;
  private final int maxConcurrentActivityTaskPollers;
  private final int maxConcurrentNexusTaskPollers;
  private final boolean localActivityWorkerOnly;
  private final long defaultDeadlockDetectionTimeout;
  private final Duration maxHeartbeatThrottleInterval;
  private final Duration defaultHeartbeatThrottleInterval;
  private final @Nonnull Duration stickyQueueScheduleToStartTimeout;
  private final boolean disableEagerExecution;
  private final int maxEagerActivityReservationsPerWorkflowTask;
  private final boolean useBuildIdForVersioning;
  private final String buildId;
  private final Duration stickyTaskQueueDrainTimeout;
  private final String identity;
  private final boolean usingVirtualThreadsOnWorkflowWorker;
  private final boolean usingVirtualThreadsOnActivityWorker;
  private final boolean usingVirtualThreadsOnLocalActivityWorker;
  private final boolean usingVirtualThreadsOnNexusWorker;
  private final WorkerDeploymentOptions deploymentOptions;
  private final PollerBehavior workflowTaskPollersBehavior;
  private final PollerBehavior activityTaskPollersBehavior;
  private final PollerBehavior nexusTaskPollersBehavior;
  private final boolean allowActivityHeartbeatDuringShutdown;
  private final PreferredVersionProvider preferredVersionProvider;
  private final boolean workflowTaskPollersConfigured;
  private final boolean activityTaskPollersConfigured;
  private final boolean nexusTaskPollersConfigured;

  private WorkerOptions(
      double maxWorkerActivitiesPerSecond,
      int maxConcurrentActivityExecutionSize,
      int maxConcurrentWorkflowTaskExecutionSize,
      int maxConcurrentLocalActivityExecutionSize,
      int maxConcurrentNexusExecutionSize,
      WorkerTuner workerTuner,
      double maxTaskQueueActivitiesPerSecond,
      int workflowPollThreadCount,
      int activityPollThreadCount,
      int nexusPollThreadCount,
      boolean localActivityWorkerOnly,
      long defaultDeadlockDetectionTimeout,
      Duration maxHeartbeatThrottleInterval,
      Duration defaultHeartbeatThrottleInterval,
      @Nonnull Duration stickyQueueScheduleToStartTimeout,
      boolean disableEagerExecution,
      int maxEagerActivityReservationsPerWorkflowTask,
      boolean useBuildIdForVersioning,
      String buildId,
      Duration stickyTaskQueueDrainTimeout,
      String identity,
      boolean useThreadsEnabledOnWorkflowWorker,
      boolean useThreadsEnabledOnActivityWorker,
      boolean virtualThreadsEnabledOnLocalActivityWorker,
      boolean virtualThreadsEnabledOnNexusWorker,
      WorkerDeploymentOptions deploymentOptions,
      PollerBehavior workflowTaskPollersBehavior,
      PollerBehavior activityTaskPollersBehavior,
      PollerBehavior nexusTaskPollersBehavior,
      boolean allowActivityHeartbeatDuringShutdown,
      PreferredVersionProvider preferredVersionProvider,
      boolean workflowTaskPollersConfigured,
      boolean activityTaskPollersConfigured,
      boolean nexusTaskPollersConfigured) {
    this.maxWorkerActivitiesPerSecond = maxWorkerActivitiesPerSecond;
    this.maxConcurrentActivityExecutionSize = maxConcurrentActivityExecutionSize;
    this.maxConcurrentWorkflowTaskExecutionSize = maxConcurrentWorkflowTaskExecutionSize;
    this.maxConcurrentLocalActivityExecutionSize = maxConcurrentLocalActivityExecutionSize;
    this.maxConcurrentNexusExecutionSize = maxConcurrentNexusExecutionSize;
    this.workerTuner = workerTuner;
    this.maxTaskQueueActivitiesPerSecond = maxTaskQueueActivitiesPerSecond;
    this.maxConcurrentWorkflowTaskPollers = workflowPollThreadCount;
    this.maxConcurrentActivityTaskPollers = activityPollThreadCount;
    this.maxConcurrentNexusTaskPollers = nexusPollThreadCount;
    this.localActivityWorkerOnly = localActivityWorkerOnly;
    this.defaultDeadlockDetectionTimeout = defaultDeadlockDetectionTimeout;
    this.maxHeartbeatThrottleInterval = maxHeartbeatThrottleInterval;
    this.defaultHeartbeatThrottleInterval = defaultHeartbeatThrottleInterval;
    this.stickyQueueScheduleToStartTimeout = stickyQueueScheduleToStartTimeout;
    this.disableEagerExecution = maxTaskQueueActivitiesPerSecond > 0 ? true : disableEagerExecution;
    this.maxEagerActivityReservationsPerWorkflowTask = maxEagerActivityReservationsPerWorkflowTask;
    this.useBuildIdForVersioning = useBuildIdForVersioning;
    this.buildId = buildId;
    this.stickyTaskQueueDrainTimeout = stickyTaskQueueDrainTimeout;
    this.identity = identity;
    this.usingVirtualThreadsOnWorkflowWorker = useThreadsEnabledOnWorkflowWorker;
    this.usingVirtualThreadsOnActivityWorker = useThreadsEnabledOnActivityWorker;
    this.usingVirtualThreadsOnLocalActivityWorker = virtualThreadsEnabledOnLocalActivityWorker;
    this.usingVirtualThreadsOnNexusWorker = virtualThreadsEnabledOnNexusWorker;
    this.deploymentOptions = deploymentOptions;
    this.workflowTaskPollersBehavior = workflowTaskPollersBehavior;
    this.activityTaskPollersBehavior = activityTaskPollersBehavior;
    this.nexusTaskPollersBehavior = nexusTaskPollersBehavior;
    this.allowActivityHeartbeatDuringShutdown = allowActivityHeartbeatDuringShutdown;
    this.preferredVersionProvider = preferredVersionProvider;
    this.workflowTaskPollersConfigured = workflowTaskPollersConfigured;
    this.activityTaskPollersConfigured = activityTaskPollersConfigured;
    this.nexusTaskPollersConfigured = nexusTaskPollersConfigured;
  }

  /**
   * Whether the workflow task pollers were left at their default (the user called neither {@link
   * Builder#setMaxConcurrentWorkflowTaskPollers} nor {@link
   * Builder#setWorkflowTaskPollersBehavior}), which makes them eligible for poller-autoscaling
   * auto-enrollment.
   */
  boolean isWorkflowTaskPollerAutoEnrollEligible() {
    return !workflowTaskPollersConfigured;
  }

  /**
   * Whether the activity task pollers were left at their default (the user called neither {@link
   * Builder#setMaxConcurrentActivityTaskPollers} nor {@link
   * Builder#setActivityTaskPollersBehavior}), which makes them eligible for poller-autoscaling
   * auto-enrollment.
   */
  boolean isActivityTaskPollerAutoEnrollEligible() {
    return !activityTaskPollersConfigured;
  }

  /**
   * Whether the nexus task pollers were left at their default (the user called neither {@link
   * Builder#setMaxConcurrentNexusTaskPollers} nor {@link Builder#setNexusTaskPollersBehavior}),
   * which makes them eligible for poller-autoscaling auto-enrollment.
   */
  boolean isNexusTaskPollerAutoEnrollEligible() {
    return !nexusTaskPollersConfigured;
  }

  public double getMaxWorkerActivitiesPerSecond() {
    return maxWorkerActivitiesPerSecond;
  }

  public int getMaxConcurrentActivityExecutionSize() {
    return maxConcurrentActivityExecutionSize;
  }

  public int getMaxConcurrentWorkflowTaskExecutionSize() {
    return maxConcurrentWorkflowTaskExecutionSize;
  }

  public int getMaxConcurrentLocalActivityExecutionSize() {
    return maxConcurrentLocalActivityExecutionSize;
  }

  public int getMaxConcurrentNexusExecutionSize() {
    return maxConcurrentNexusExecutionSize;
  }

  public double getMaxTaskQueueActivitiesPerSecond() {
    return maxTaskQueueActivitiesPerSecond;
  }

  /**
   * @deprecated use {@link #getMaxConcurrentWorkflowTaskPollers}
   */
  @Deprecated
  public int getWorkflowPollThreadCount() {
    return getMaxConcurrentWorkflowTaskPollers();
  }

  public int getMaxConcurrentWorkflowTaskPollers() {
    return maxConcurrentWorkflowTaskPollers;
  }

  /**
   * @deprecated use {@link #getMaxConcurrentActivityTaskPollers}
   */
  @Deprecated
  public int getActivityPollThreadCount() {
    return getMaxConcurrentActivityTaskPollers();
  }

  public int getMaxConcurrentActivityTaskPollers() {
    return maxConcurrentActivityTaskPollers;
  }

  public int getMaxConcurrentNexusTaskPollers() {
    return maxConcurrentNexusTaskPollers;
  }

  public long getDefaultDeadlockDetectionTimeout() {
    return defaultDeadlockDetectionTimeout;
  }

  public boolean isLocalActivityWorkerOnly() {
    return localActivityWorkerOnly;
  }

  public Duration getMaxHeartbeatThrottleInterval() {
    return maxHeartbeatThrottleInterval;
  }

  public Duration getDefaultHeartbeatThrottleInterval() {
    return defaultHeartbeatThrottleInterval;
  }

  @Nonnull
  public Duration getStickyQueueScheduleToStartTimeout() {
    return stickyQueueScheduleToStartTimeout;
  }

  public boolean isEagerExecutionDisabled() {
    return disableEagerExecution;
  }

  public int getMaxEagerActivityReservationsPerWorkflowTask() {
    return maxEagerActivityReservationsPerWorkflowTask;
  }

  public boolean isUsingBuildIdForVersioning() {
    return useBuildIdForVersioning;
  }

  public String getBuildId() {
    return buildId;
  }

  public Duration getStickyTaskQueueDrainTimeout() {
    return stickyTaskQueueDrainTimeout;
  }

  public WorkerTuner getWorkerTuner() {
    return workerTuner;
  }

  @Nullable
  public String getIdentity() {
    return identity;
  }

  public boolean isUsingVirtualThreadsOnWorkflowWorker() {
    return usingVirtualThreadsOnWorkflowWorker;
  }

  public boolean isUsingVirtualThreadsOnActivityWorker() {
    return usingVirtualThreadsOnActivityWorker;
  }

  public boolean isUsingVirtualThreadsOnLocalActivityWorker() {
    return usingVirtualThreadsOnLocalActivityWorker;
  }

  public boolean isUsingVirtualThreadsOnNexusWorker() {
    return usingVirtualThreadsOnNexusWorker;
  }

  @Experimental
  public WorkerDeploymentOptions getDeploymentOptions() {
    return deploymentOptions;
  }

  public PollerBehavior getWorkflowTaskPollersBehavior() {
    return workflowTaskPollersBehavior;
  }

  public PollerBehavior getActivityTaskPollersBehavior() {
    return activityTaskPollersBehavior;
  }

  public PollerBehavior getNexusTaskPollersBehavior() {
    return nexusTaskPollersBehavior;
  }

  @Experimental
  public boolean getAllowActivityHeartbeatDuringShutdown() {
    return allowActivityHeartbeatDuringShutdown;
  }

  @Experimental
  public PreferredVersionProvider getPreferredVersionProvider() {
    return preferredVersionProvider;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    WorkerOptions that = (WorkerOptions) o;
    return compare(maxWorkerActivitiesPerSecond, that.maxWorkerActivitiesPerSecond) == 0
        && maxConcurrentActivityExecutionSize == that.maxConcurrentActivityExecutionSize
        && maxConcurrentWorkflowTaskExecutionSize == that.maxConcurrentWorkflowTaskExecutionSize
        && maxConcurrentLocalActivityExecutionSize == that.maxConcurrentLocalActivityExecutionSize
        && maxConcurrentNexusExecutionSize == that.maxConcurrentNexusExecutionSize
        && compare(maxTaskQueueActivitiesPerSecond, that.maxTaskQueueActivitiesPerSecond) == 0
        && maxConcurrentWorkflowTaskPollers == that.maxConcurrentWorkflowTaskPollers
        && maxConcurrentActivityTaskPollers == that.maxConcurrentActivityTaskPollers
        && maxConcurrentNexusTaskPollers == that.maxConcurrentNexusTaskPollers
        && localActivityWorkerOnly == that.localActivityWorkerOnly
        && defaultDeadlockDetectionTimeout == that.defaultDeadlockDetectionTimeout
        && disableEagerExecution == that.disableEagerExecution
        && maxEagerActivityReservationsPerWorkflowTask
            == that.maxEagerActivityReservationsPerWorkflowTask
        && useBuildIdForVersioning == that.useBuildIdForVersioning
        && Objects.equals(workerTuner, that.workerTuner)
        && Objects.equals(maxHeartbeatThrottleInterval, that.maxHeartbeatThrottleInterval)
        && Objects.equals(defaultHeartbeatThrottleInterval, that.defaultHeartbeatThrottleInterval)
        && Objects.equals(stickyQueueScheduleToStartTimeout, that.stickyQueueScheduleToStartTimeout)
        && Objects.equals(buildId, that.buildId)
        && Objects.equals(stickyTaskQueueDrainTimeout, that.stickyTaskQueueDrainTimeout)
        && Objects.equals(identity, that.identity)
        && usingVirtualThreadsOnWorkflowWorker == that.usingVirtualThreadsOnWorkflowWorker
        && usingVirtualThreadsOnActivityWorker == that.usingVirtualThreadsOnActivityWorker
        && usingVirtualThreadsOnLocalActivityWorker == that.usingVirtualThreadsOnLocalActivityWorker
        && usingVirtualThreadsOnNexusWorker == that.usingVirtualThreadsOnNexusWorker
        && Objects.equals(deploymentOptions, that.deploymentOptions)
        && Objects.equals(workflowTaskPollersBehavior, that.workflowTaskPollersBehavior)
        && Objects.equals(activityTaskPollersBehavior, that.activityTaskPollersBehavior)
        && Objects.equals(nexusTaskPollersBehavior, that.nexusTaskPollersBehavior)
        && allowActivityHeartbeatDuringShutdown == that.allowActivityHeartbeatDuringShutdown
        && Objects.equals(preferredVersionProvider, that.preferredVersionProvider);
  }

  @Override
  public int hashCode() {
    return Objects.hash(
        maxWorkerActivitiesPerSecond,
        maxConcurrentActivityExecutionSize,
        maxConcurrentWorkflowTaskExecutionSize,
        maxConcurrentLocalActivityExecutionSize,
        maxConcurrentNexusExecutionSize,
        workerTuner,
        maxTaskQueueActivitiesPerSecond,
        maxConcurrentWorkflowTaskPollers,
        maxConcurrentActivityTaskPollers,
        maxConcurrentNexusTaskPollers,
        localActivityWorkerOnly,
        defaultDeadlockDetectionTimeout,
        maxHeartbeatThrottleInterval,
        defaultHeartbeatThrottleInterval,
        stickyQueueScheduleToStartTimeout,
        disableEagerExecution,
        maxEagerActivityReservationsPerWorkflowTask,
        useBuildIdForVersioning,
        buildId,
        stickyTaskQueueDrainTimeout,
        identity,
        usingVirtualThreadsOnWorkflowWorker,
        usingVirtualThreadsOnActivityWorker,
        usingVirtualThreadsOnLocalActivityWorker,
        usingVirtualThreadsOnNexusWorker,
        deploymentOptions,
        workflowTaskPollersBehavior,
        activityTaskPollersBehavior,
        nexusTaskPollersBehavior,
        allowActivityHeartbeatDuringShutdown,
        preferredVersionProvider);
  }

  @Override
  public String toString() {
    return "WorkerOptions{"
        + "maxWorkerActivitiesPerSecond="
        + maxWorkerActivitiesPerSecond
        + ", maxConcurrentActivityExecutionSize="
        + maxConcurrentActivityExecutionSize
        + ", maxConcurrentWorkflowTaskExecutionSize="
        + maxConcurrentWorkflowTaskExecutionSize
        + ", maxConcurrentLocalActivityExecutionSize="
        + maxConcurrentLocalActivityExecutionSize
        + ", maxConcurrentNexusExecutionSize="
        + maxConcurrentNexusExecutionSize
        + ", workerTuner="
        + workerTuner
        + ", maxTaskQueueActivitiesPerSecond="
        + maxTaskQueueActivitiesPerSecond
        + ", maxConcurrentWorkflowTaskPollers="
        + maxConcurrentWorkflowTaskPollers
        + ", maxConcurrentActivityTaskPollers="
        + maxConcurrentActivityTaskPollers
        + ", maxConcurrentNexusTaskPollers="
        + maxConcurrentNexusTaskPollers
        + ", localActivityWorkerOnly="
        + localActivityWorkerOnly
        + ", defaultDeadlockDetectionTimeout="
        + defaultDeadlockDetectionTimeout
        + ", maxHeartbeatThrottleInterval="
        + maxHeartbeatThrottleInterval
        + ", defaultHeartbeatThrottleInterval="
        + defaultHeartbeatThrottleInterval
        + ", stickyQueueScheduleToStartTimeout="
        + stickyQueueScheduleToStartTimeout
        + ", disableEagerExecution="
        + disableEagerExecution
        + ", maxEagerActivityReservationsPerWorkflowTask="
        + maxEagerActivityReservationsPerWorkflowTask
        + ", useBuildIdForVersioning="
        + useBuildIdForVersioning
        + ", buildId='"
        + buildId
        + '\''
        + ", stickyTaskQueueDrainTimeout="
        + stickyTaskQueueDrainTimeout
        + ", identity="
        + identity
        + ", usingVirtualThreadsOnWorkflowWorker="
        + usingVirtualThreadsOnWorkflowWorker
        + ", usingVirtualThreadsOnActivityWorker="
        + usingVirtualThreadsOnActivityWorker
        + ", usingVirtualThreadsOnLocalActivityWorker="
        + usingVirtualThreadsOnLocalActivityWorker
        + ", usingVirtualThreadsOnNexusWorker="
        + usingVirtualThreadsOnNexusWorker
        + ", deploymentOptions="
        + deploymentOptions
        + ", workflowTaskPollersBehavior="
        + workflowTaskPollersBehavior
        + ", activityTaskPollersBehavior="
        + activityTaskPollersBehavior
        + ", nexusTaskPollersBehavior="
        + nexusTaskPollersBehavior
        + ", allowActivityHeartbeatDuringShutdown="
        + allowActivityHeartbeatDuringShutdown
        + ", preferredVersionProvider="
        + preferredVersionProvider
        + '}';
  }
}

temporalio / sdk-java / #345

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous