-nominal callbacks() :: [module()].

Initial list of callback modules implementing wpool_process_callbacks to be called on certain worker events.

This options will only work if the enable_callbacks is set to true.

Callbacks can be added and removed later by wpool_pool:add_callback_module/2 and wpool_pool:remove_callback_module/2.

-nominal custom_strategy() :: fun((atom()) -> Atom :: atom()).

A callback that gets the pool name and returns a worker's name.

-nominal enable_callbacks() :: boolean().

A boolean value determining if event_manager should be started for callback modules.

Defaults to false.

-nominal enable_queues() :: boolean().

A boolean value determining if queue_manager should be started for queueing requests.

Defaults to true.

Disabling this will disable available_worker and next_available_worker strategies.

-nominal max_overrun_warnings() :: infinity | pos_integer().

The maximum number of overrun warnings emitted before killing the worker with a delayed task.

If this parameter is set to a value other than infinity the rounds of warnings become equally timed (i.e. with overrun_warning = 1000 and max_overrun_warnings = 5 the task would be killed after 5 seconds of execution).

The default value for this setting is infinity, i.e., delayed tasks are not killed.

As the worker is being killed it might cause worker's messages to be missing if you are using a worker stategy other than available_worker.

-nominal name() :: atom().

Name of the pool.

-nominal option() ::
             {workers, workers()} |
             {worker, worker()} |
             {worker_opt, [gen_server:start_opt()]} |
             {strategy, supervisor:sup_flags()} |
             {worker_shutdown, worker_shutdown()} |
             {overrun_handler, overrun_handler() | [overrun_handler()]} |
             {overrun_warning, overrun_warning()} |
             {max_overrun_warnings, max_overrun_warnings()} |
             {pool_sup_intensity, pool_sup_intensity()} |
             {pool_sup_shutdown, pool_sup_shutdown()} |
             {pool_sup_period, pool_sup_period()} |
             {queue_type, queue_type()} |
             {enable_callbacks, enable_callbacks()} |
             {enable_queues, enable_queues()} |
             {callbacks, callbacks()}.

Options that can be provided to a new pool.

child_spec/2, start_pool/2, start_sup_pool/2 are the callbacks that take a list of these options as a parameter.

-nominal options() ::
             #{workers => workers(),
               worker => worker(),
               worker_opt => [gen_server:start_opt()],
               strategy => supervisor:sup_flags(),
               worker_shutdown => worker_shutdown(),
               overrun_handler => overrun_handler() | [overrun_handler()],
               overrun_warning => overrun_warning(),
               max_overrun_warnings => max_overrun_warnings(),
               pool_sup_intensity => pool_sup_intensity(),
               pool_sup_shutdown => pool_sup_shutdown(),
               pool_sup_period => pool_sup_period(),
               queue_type => queue_type(),
               enable_callbacks => enable_callbacks(),
               enable_queues => enable_queues(),
               callbacks => callbacks(),
               _ => _}.

Options that can be provided to a new pool.

child_spec/2, start_pool/2, start_sup_pool/2 are the callbacks that take a list of these options as a parameter.

-nominal overrun_handler() :: {Module :: module(), Fun :: atom()}.

The module and function to call when a task is overrun.

The default value for this setting is {logger, warning}. The function must be of arity 1, and it will be called asModule:Fun(Args) where Args is a proplist with the following reported values:

• {alert, AlertType}: Where AlertType is overrun on regular warnings, or max_overrun_limit when the worker is about to be killed.
• {pool, Pool}: The pool name.
• {worker, Pid}: Pid of the worker.
• {task, Task}: A description of the task.
• {runtime, Runtime}: The runtime of the current round.

-nominal overrun_warning() :: infinity | pos_integer().

The number of milliseconds after which a task is considered overrun i.e., delayed.

A warning is emitted using overrun_handler().

The task is monitored until it is finished, thus more than one warning might be emitted for a single task.

The rounds of warnings are not equally timed, an exponential backoff algorithm is used instead: after each warning the overrun time is doubled (i.e. with overrun_warning = 1000 warnings would be emitted after 1000, 2000, 4000, 8000 ...).

The default value for this setting is infinity, i.e., no warnings are emitted.

-nominal pool_sup_intensity() :: non_neg_integer().

The supervision intensity to use over the supervisor that supervises the workers.

Defaults to 5.

See wpool_pool for more details.

-nominal pool_sup_period() :: non_neg_integer().

The supervision period to use over the supervisor that supervises the workers.

Defaults to 60.

See wpool_pool for more details.

-nominal pool_sup_shutdown() :: brutal_kill | timeout().

The shutdown option to be used over the supervisor that supervises the workers.

Defaults to brutal_kill.

See wpool_process_sup for more details.

-nominal queue_type() :: fifo | lifo.

Order in which requests will be stored and handled by workers.

Defaults to fifo.

-nominal run(Result) :: fun((name() | pid(), timeout()) -> Result).

A function to run with a given worker.

It can be used to enable APIs that hide the gen_server behind a complex logic that might for example curate parameters or run side-effects, for example, supervisor.

For example:

    Opts = #{
        workers => 3,
        worker_shutdown => infinity,
        worker => {supervisor, {Name, ModuleCallback, Args}}
    },
    %% Note that the supervisor's `init/1` callback takes such 3-tuple.
    {ok, Pid} = wpool:start_sup_pool(pool_of_supervisors, Opts),
...

    Run = fun(Sup, _) -> supervisor:start_child(Sup, Params) end,
    {ok, Pid} = wpool:run(pool_of_supervisors, Run, next_worker),

-nominal stats() ::
             [{pool, name()} |
              {supervisor, pid()} |
              {options, [option()] | options()} |
              {size, non_neg_integer()} |
              {next_worker, pos_integer()} |
              {total_message_queue_len, non_neg_integer()} |
              {workers, [{pos_integer(), worker_stats()}]}].

Statistics about a given live pool.

-nominal strategy() ::
             best_worker | random_worker | next_worker | available_worker | next_available_worker |
             {hash_worker, term()} |
             custom_strategy().

Strategy to use when choosing a worker.

best_worker

Picks the worker with the shortest queue of messages. Loosely based on this article.

This strategy is usually useful when your workers always perform the same task, or tasks with expectedly similar runtimes.

random_worker

Just picks a random worker. This strategy is the fastest one to select a worker. It's ideal if your workers will perform many short tasks.

next_worker

Picks the next worker in a round-robin fashion. This ensures an evenly distribution of tasks.

available_worker

Instead of just picking one of the workers in the queue and sending the request to it, this strategy queues the request and waits until a worker is available to perform it. That may render the worker selection part of the process much slower (thus generating the need for an additional parameter: Worker_Timeout' that controls how many milliseconds the client is willing to spend in that, regardless of the globalTimeout' for the call).

This strategy ensures that, if a worker crashes, no messages are lost in its message queue. It also ensures that, if a task takes too long, that doesn't block other tasks since, as soon as other worker is free it can pick up the next task in the list.

next_available_worker

In a way, this strategy behaves like available_worker in the sense that it will pick the first worker that it can find which is not running any task at the moment, but the difference is that it will fail if all workers are busy.

{hash_worker, Key}

This strategy takes a Key and selects a worker using erlang:phash2/2. This ensures that tasks classified under the same key will be delivered to the same worker, which is useful to classify events by key and work on them sequentially on the worker, distributing different keys across different workers.

custom_strategy()

A callback that gets the pool name and returns a worker's name.

-nominal worker() :: {Module :: module(), InitArg :: term()}.

The gen_server module and the arguments to pass to the init callback.

This is the module that each worker will run and the InitArgs to use on the corresponding start_link call used to initiate it.

The default value for this setting is {wpool_worker, undefined}. That means that if you don't provide a worker implementation, the pool will be generated with this default one.

See wpool_worker for details.

-nominal worker_shutdown() :: brutal_kill | timeout().

The shutdown option to be used over the individual workers.

Defaults to 5000.

See wpool_process_sup for more details.

-nominal worker_stats() :: [{messsage_queue_len, non_neg_integer()} | {memory, pos_integer()}].

Statistics about a worker in a pool.

-nominal workers() :: pos_integer().

The number of workers in the pool.

The default value for this setting is 100.