supervisor(3erl)

📦
version 25.3.2.8 · 5 versions
, in ubuntu noble

🌸 supervisor(3erl) — Erlang Module Definition 🌸

okay so first thing, bestie: the manual name is supervisor, it lives in the Erlang Module Definition section, and it's literally the blueprint for one of the most iconic things in OTP. let's get into it 💅

✨ NAME ✨

supervisor — the generic supervisor behavior. she supervises, that's the whole job 🎀

💖 DESCRIPTION 💖

so this behavior module gives you a supervisor: a process whose entire personality is supervising other processes, which we call child processes. very main character energy, very "i don't do the work, i make sure the work gets done." 👑

now, each child process can be one of two things:

  • another supervisor — yes, supervisors supervising supervisors, it's giving supervision-ception 🌀
  • a worker process — the ones actually out here doing stuff

worker processes are normally implemented using one of these behaviors:

  • gen_event
  • gen_server
  • gen_statem

and a supervisor implemented using this module comes with a standard set of interface functions, plus functionality for tracing and error reporting. so you get the whole package, no cap. ✨

supervisors are how you build a hierarchical process structure called a supervision tree — and ngl, it's genuinely a nice way to structure a fault-tolerant application. the tree is the vibe. the tree is the moment. 🌈🌳

for more information, see Supervisor Behaviour in OTP Design Principles. (iykyk, go read it 🫶)

another thing: a supervisor expects the definition of which child processes to supervise to be specified in a callback module that exports a predefined set of functions. so you don't just vibe your way into it — you hand her a callback module and she takes it from there. 📋

⚠️ and listen, unless otherwise stated, all functions in this module fail if the specified supervisor does not exist, or if bad arguments are specified. so like… don't do that. 🙈

💅 SUPERVISION PRINCIPLES 💅

Okay so a supervisor is literally the main character of keeping its child processes alive: it starts them, stops them, monitors them, and restarts them when necessary. The basic idea? It must keep its child processes alive by restarting them when necessary. fr fr.

The children of a supervisor are defined as a list of child specifications. When the supervisor is started, the child processes are started in order from left to right according to this list. When the supervisor terminates, it first terminates its child processes in reversed start order, from right to left.

🎀 Supervisor flags 🎀

The supervisor properties are defined by the supervisor flags. The type definition for the supervisor flags is as follows:

sup_flags() = #{strategy => strategy(),           % optional
                intensity => non_neg_integer(),   % optional
                period => pos_integer(),          % optional
                auto_shutdown => auto_shutdown()} % optional

🔥 Restart Strategies 🔥

A supervisor can have one of the following restart strategies specified with the strategy key in the above map:

  • one_for_one — If one child process terminates and is to be restarted, only that child process is affected. This is the default restart strategy. ✨
  • one_for_all — If one child process terminates and is to be restarted, all other child processes are terminated and then all child processes are restarted.
  • rest_for_one — If one child process terminates and is to be restarted, the 'rest' of the child processes (that is, the child processes after the terminated child process in the start order) are terminated. Then the terminated child process and all child processes after it are restarted. iykyk.
  • simple_one_for_one — A simplified one_for_one supervisor, where all child processes are dynamically added instances of the same process type, that is, running the same code.

Functions delete_child/2 and restart_child/2 are invalid for simple_one_for_one supervisors and return {error,simple_one_for_one} if the specified supervisor uses this restart strategy.

Function terminate_child/2 can be used for children under simple_one_for_one supervisors by specifying the child's pid() as the second argument. If instead the child specification identifier is used, terminate_child/2 return {error,simple_one_for_one}.

As a simple_one_for_one supervisor can have many children, it shuts them all down asynchronously. This means that the children do their cleanup in parallel, and therefore the order in which they are stopped is not defined. 💀

⏱️ Restart intensity and period ⏱️

To prevent a supervisor from getting into an infinite loop of child process terminations and restarts, a maximum restart intensity is defined using two integer values specified with keys intensity and period in the above map. Assuming the values MaxR for intensity and MaxT for period, then, if more than MaxR restarts occur within MaxT seconds, the supervisor terminates all child processes and then itself. The termination reason for the supervisor itself in that case will be shutdown. intensity defaults to 1 and period defaults to 5. 🕔

🛑 Automatic Shutdown 🛑

A supervisor can be configured to automatically shut itself down with exit reason shutdown when significant children terminate with the auto_shutdown key in the above map:

  • never — Automatic shutdown is disabled. This is the default setting.

With auto_shutdown set to never, child specs with the significant flag set to true are considered invalid and will be rejected.

  • any_significant — The supervisor will shut itself down when any significant child terminates, that is, when a transient significant child terminates normally or when a temporary significant child terminates normally or abnormally.
  • all_significant — The supervisor will shut itself down when all significant children have terminated, that is, when the last active significant child terminates. The same rules as for any_significant apply.

For more information, see the section Automatic Shutdown in Supervisor Behavior in OTP Design Principles.

⚠️ Warning: The automatic shutdown feature appeared in OTP 24.0, but applications using this feature will also compile and run with older OTP versions. However, such applications, when compiled with an OTP version that predates the appearance of the automatic shutdown feature, will leak processes because the automatic shutdowns they rely on will not happen. It is up to implementors to take proper precautions if they expect that their applications may be compiled with older OTP versions.

🧸 Child specification 🧸

The type definition of a child specification is as follows:

child_spec() = #{id => child_id(),             % mandatory
                 start => mfargs(),            % mandatory
                 restart => restart(),         % optional
                 significant => significant(), % optional
                 shutdown => shutdown(),       % optional
                 type => worker(),             % optional
                 modules => modules()}         % optional

The old tuple format is kept for backwards compatibility, see child_spec(), but the map is preferred. 🫶

  • id — is used to identify the child specification internally by the supervisor.

The id key is mandatory.

Notice that this identifier on occasions has been called "name". As far as possible, the terms "identifier" or "id" are now used but to keep backward compatibility, some occurrences of "name" can still be found, for example in error messages.

  • start — defines the function call used to start the child process. It must be a module-function-arguments tuple {M,F,A} used as apply(M,F,A).

The start function must create and link to the child process, and must return {ok,Child} or {ok,Child,Info}, where Child is the pid of the child process and Info any term that is ignored by the supervisor.

The start function can also return ignore if the child process for some reason cannot be started, in which case the child specification is kept by the supervisor (unless it is a temporary child) but the non-existing child process is ignored.

If something goes wrong, the function can also return an error tuple {error,Error}.

Notice that the start_link functions of the different behavior modules fulfill the above requirements.

The start key is mandatory.

  • restart — defines when a terminated child process must be restarted. A permanent child process is always restarted. A temporary child process is never restarted (even when the supervisor's restart strategy is rest_for_one or one_for_all and a sibling's death causes the temporary process to be terminated). A transient child process is restarted only if it terminates abnormally, that is, with another exit reason than normal, shutdown, or {shutdown,Term}.

The restart key is optional. If it is not specified, it defaults to permanent.

  • significant — defines if a child is considered significant for automatic self-shutdown of the supervisor.

Setting this option to true when the restart type is permanent is invalid. Also, it is considered invalid to start children with this option set to true in a supervisor when the auto_shutdown supervisor flag is set to never.

The significant key is optional. If it is not specified, it defaults to false.

  • shutdown — defines how a child process must be terminated. brutal_kill means that the child process is unconditionally terminated using exit(Child,kill). An integer time-out value means that the supervisor tells the child process to terminate by calling exit(Child,shutdown) and then wait for an exit signal with reason shutdown back from the child process. If no exit signal is received within the specified number of milliseconds, the child process is unconditionally terminated using exit(Child,kill).

If the child process is another supervisor, the shutdown time must be set to infinity to give the subtree ample time to shut down.

⚠️ Warning: Setting the shutdown time to anything other than infinity for a child of type supervisor can cause a race condition where the child in question unlinks its own children, but fails to terminate them before it is killed.

It is also allowed to set it to infinity, if the child process is a worker.

⚠️ Warning: Be careful when setting the shutdown time to infinity when the child process is a worker. Because, in this situation, the termination of the supervision tree depends on the child process, it must be implemented in a safe way and its cleanup procedure must always return.

Notice that all child processes implemented using the standard OTP behavior modules automatically adhere to the shutdown protocol.

The shutdown key is optional. If it is not specified, it defaults to 5000 if the child is of type worker and it defaults to infinity if the child is of type supervisor.

  • type — specifies if the child process is a supervisor or a worker.

The type key is optional. If it is not specified, it defaults to worker.

  • modules — is used by the release handler during code replacement to determine which processes are using a certain module. As a rule of thumb, if the child process is a supervisor, gen_server or gen_statem, this is to be a list with one element [Module], where Module is the callback module. If the child process is an event manager (gen_event) with a dynamic set of callback modules, value dynamic must be used. For more information about release handling, see Release Handling in OTP Design Principles.

The modules key is optional. If it is not specified, it defaults to [M], where M comes from the child's start {M,F,A}.

  • Internally, the supervisor also keeps track of the pid Child of the child process, or undefined if no pid exists.

🦋 child_id() 🦋

child_id() = term()

It's literally not a pid(), bestie. Do not come for me on that one.

🎀 child_spec() 🎀

#{id := child_id(),
  start := mfargs(),
  restart => restart(),
  significant => significant(),
  shutdown => shutdown(),
  type => worker(),
  modules => modules()} |
{Id :: child_id(),
 StartFunc :: mfargs(),
 Restart :: restart(),
 Shutdown :: shutdown(),
 Type :: worker(),
 Modules :: modules()}

The tuple format is living here purely for backward compatibility — it's giving legacy, ngl. The map form is what you actually want; more deets are up above. ✨

🌸 mfargs() 🌸

{M :: module(), F :: atom(), A :: [term()] | undefined}

The undefined value for A (the argument list) is only for internal use inside supervisor — don't be out here passing it yourself. If a child's restart type is temporary, that process is never getting restarted, so there's literally no point storing the real argument list. So undefined gets tucked in there instead. 💅

🦋 modules() 🦋

modules() = [module()] | dynamic

🍓 restart() 🍓

restart() = permanent | transient | temporary

🧚 shutdown() 🧚

shutdown() = brutal_kill | timeout()

⭐ significant() ⭐

significant() = boolean()

💜 startchild_err() 💜

already_present | {already_started, Child :: child()} | term()

💜 startchild_ret() 💜

{ok, Child :: child()} |
{ok, Child :: child(), Info :: term()} |
{error, startchild_err()}
{already_started, pid()} | {shutdown, term()} | term()
{ok, pid()} | ignore | {error, startlink_err()}

👑 strategy() 👑

strategy() = one_for_all | one_for_one | rest_for_one | simple_one_for_one

🌈 sup_flags() 🌈

#{strategy => strategy(),
  intensity => integer() >= 0,
  period => integer() >= 1,
  auto_shutdown => auto_shutdown()} |
{RestartStrategy :: strategy(),
 Intensity :: integer() >= 0,
 Period :: integer() >= 1}

Same story as child_spec() — the tuple version is kept for backward compatibility only, map is the moment. Details are above. 🫶

🎀 sup_ref() 🎀

(Name :: atom()) |
{Name :: atom(), Node :: node()} |
{global, Name :: term()} |
{via, Module :: module(), Name :: any()} |
pid()

🦋 worker() 🦋

worker() = worker | supervisor

💅 EXPORTS 💅

✨ check_childspecs(ChildSpecs) -> Result ✨

✨ check_childspecs(ChildSpecs, AutoShutdown) -> Result ✨

Types:

ChildSpecs = [child_spec()]
AutoShutdown = undefined | auto_shutdown()
Result = ok | {error, Error :: term()}

You hand it a list of child specs as the argument, and it hits you back with ok if every single one of them is syntactically correct. If not? {error,Error}, obviously. 😭

And if you pass that optional AutoShutdown argument and it's not undefined, it also checks whether the child specs are allowed for the given auto_shutdown option. Double-duty icon. 🔥

✨ count_children(SupRef) -> PropListOfCounts ✨

Types:

SupRef = sup_ref()
PropListOfCounts = [Count]
Count =
    {specs, ChildSpecCount :: integer() >= 0} |
    {active, ActiveProcessCount :: integer() >= 0} |
    {supervisors, ChildSupervisorCount :: integer() >= 0} |
    {workers, ChildWorkerCount :: integer() >= 0}

Returns a property list (peep proplists) with the counts for each of these elements of the supervisor's child specifications and managed processes:

  • specs — the total count of children, dead or alive. Everyone's invited.
  • active — the count of all actively running child processes managed by this supervisor. For simple_one_for_one supervisors, no check is done to make sure each child process is still alive — although the result you get here is likely to be very accurate unless the supervisor is heavily overloaded. She's doing her best. 🙈
  • supervisors — the count of all children marked as child_type = supervisor in the specification list, regardless of whether the child process is still alive.
  • workers — the count of all children marked as child_type = worker in the specification list, regardless of whether the child process is still alive.

For a description of SupRef, see start_child/2. 👀

✨ delete_child(SupRef, Id) -> Result ✨

Types:

SupRef = sup_ref()
Id = child_id()
Result = ok | {error, Error}
Error = running | restarting | not_found | simple_one_for_one

Tells supervisor SupRef to delete the child specification identified by Id. Girlboss move, but — the corresponding child process must not be running. Use terminate_child/2 to terminate it first, bestie. Don't skip that step. 💀

For a description of SupRef, see start_child/2.

If it works you get ok. If the child spec identified by Id exists but the corresponding child process is running, or is about to be restarted, you get {error,running} or {error,restarting} respectively. And if the child spec identified by Id doesn't exist at all? {error,not_found}. Slipped into the void. 🫠

✨ get_childspec(SupRef, Id) -> Result ✨

Types:

SupRef = sup_ref()
Id = pid() | child_id()
Result = {ok, child_spec()} | {error, Error}
Error = not_found

Returns the child specification map for the child identified by Id under supervisor SupRef. And the returned map contains all the keys — mandatory and optional. Full transparency, no gatekeeping. ✨

For a description of SupRef, see start_child/2.

✨ restart_child(SupRef, Id) -> Result ✨

Types:

SupRef = sup_ref()
Id = child_id()
Result =
    {ok, Child :: child()} |
    {ok, Child :: child(), Info :: term()} |
    {error, Error}
Error =
    running | restarting | not_found | simple_one_for_one |
term()

Tells supervisor SupRef to restart a child process corresponding to the child specification identified by Id. The child spec has to exist, and the corresponding child process must not be running. No double-dipping. 🚫

⚠️ Real talk: for temporary children, the child specification gets automatically deleted the moment the child terminates. So it is not possible to restart those children. Ever. That's the whole vibe of temporary. 😭

For a description of SupRef, see start_child/2.

If the child spec identified by Id doesn't exist, you get {error,not_found}. If the spec exists but the corresponding process is already running, you get {error,running}.

If the child process start function returns {ok,Child} or {ok,Child,Info}, the pid gets added to the supervisor and the function returns that same value. Slay.

If the child process start function returns ignore, the pid stays set to undefined and the function returns {ok,undefined}. Iconic neutrality.

And if the child process start function returns an error tuple or an erroneous value, or if it fails? You get {error,Error}, where Error is a term containing info about the error. F in the chat. 🫡

✨ start_child(SupRef, ChildSpec) -> startchild_ret() ✨

Types:

SupRef = sup_ref()
ChildSpec = child_spec() | (List :: [term()])
startchild_ret() =
    {ok, Child :: child()} |
    {ok, Child :: child(), Info :: term()} |
    {error, startchild_err()}
startchild_err() =
    already_present | {already_started, Child :: child()} | term()

Dynamically adds a child specification to supervisor SupRef, which then starts the corresponding child process. Glow-up in real time. ✨

SupRef can be any of these cuties:

  • The pid
  • Name, if the supervisor is locally registered
  • {Name,Node}, if the supervisor is locally registered at another node
  • {global,Name}, if the supervisor is globally registered
  • {via,Module,Name}, if the supervisor is registered through an alternative process registry

ChildSpec must be a valid child specification (unless the supervisor is a simple_one_for_one supervisor — see below 👇). The child process gets started by using the start function as defined in the child specification.

For a simple_one_for_one supervisor, the child specification defined in Module:init/1 is the one used, and ChildSpec must instead be an arbitrary list of terms List. The child process is then started by appending List to the existing start function arguments — that is, by calling apply(M, F, A++List), where {M,F,A} is the start function defined in the child specification. Math. 🧮

  • If a child specification with the specified identifier already exists, ChildSpec is discarded, and the function returns {error,already_present} or {error,{already_started,Child}} — depending on whether the corresponding child process is running or not.
  • If the child process start function returns {ok,Child} or {ok,Child,Info}, the child specification and pid are added to the supervisor and the function returns the same value. Periodt.
  • If the child process start function returns ignore, the child specification is added to the supervisor (unless the supervisor is a simple_one_for_one supervisor, see below), the pid is set to undefined, and the function returns {ok,undefined}.

For a simple_one_for_one supervisor, when a child process start function returns ignore, the function returns {ok,undefined} and no child gets added to the supervisor. Not one. Zero. 💀

If the child process start function returns an error tuple or an erroneous value, or if it fails, the child specification is discarded, and the function returns {error,Error}, where Error is a term containing information about the error and the child specification. Messy but honest. 😭

Types:

Types, continued (we were literally mid-block, bestie):

                 SupName = sup_name()
                 Module = module()
                 Args = term()
                 startlink_ret() =
                     {ok, pid()} | ignore | {error, startlink_err()}
                 startlink_err() =
                     {already_started, pid()} | {shutdown, term()} | term()
                 sup_name() =
                     {local, Name :: atom()} |
                     {global, Name :: term()} |
                     {via, Module :: module(), Name :: any()}

Okay so start_link/2,3 creates a supervisor process as part of a supervision tree. For example, the function ensures that the supervisor is linked to the calling process (its supervisor). 💅

The created supervisor process calls Module:init/1 to find out about restart strategy, maximum restart intensity, and child processes. To ensure a synchronized startup procedure, start_link/2,3 does not return until Module:init/1 has returned and all child processes have been started. Slay, synchronized. ✨

  • If SupName={local,Name}, the supervisor is registered locally as Name using register/2.
  • If SupName={global,Name}, the supervisor is registered globally as Name using global:register_name/2.
  • If SupName={via,Module,Name}, the supervisor is registered as Name using the registry represented by Module. The Module callback must export the functions register_name/2, unregister_name/1, and send/2, which must behave like the corresponding functions in global. Thus, {via,global,Name} is a valid reference.

If no name is provided, the supervisor is not registered. No cap.

Module is the name of the callback module.

Args is any term that is passed as the argument to Module:init/1.

  • If the supervisor and its child processes are successfully created (that is, if all child process start functions return {ok,Child}, {ok,Child,Info}, or ignore), the function returns {ok,Pid}, where Pid is the pid of the supervisor.
  • If there already exists a process with the specified SupName, the function returns {error,{already_started,Pid}}, where Pid is the pid of that process.
  • If Module:init/1 returns ignore, this function returns ignore as well, and the supervisor terminates with reason normal.
  • If Module:init/1 fails or returns an incorrect value, this function returns {error,Term}, where Term is a term with information about the error, and the supervisor terminates with reason Term.
  • If any child process start function fails or returns an error tuple or an erroneous value, the supervisor first terminates all already started child processes with reason shutdown and then terminate itself and returns {error, {shutdown, Reason}}.

terminate_child(SupRef, Id) -> Result

Types:

                 SupRef = sup_ref()
                 Id = pid() | child_id()
                 Result = ok | {error, Error}
                 Error = not_found | simple_one_for_one

Tells supervisor SupRef to terminate the specified child. Bye bestie, but make it supervised. 💀

If the supervisor is not simple_one_for_one, Id must be the child specification identifier. The process, if any, is terminated and, unless it is a temporary child, the child specification is kept by the supervisor. The child process can later be restarted by the supervisor. The child process can also be restarted explicitly by calling restart_child/2. Use delete_child/2 to remove the child specification.

If the child is temporary, the child specification is deleted as soon as the process terminates. This means that delete_child/2 has no meaning and restart_child/2 cannot be used for these children. 🫠

If the supervisor is simple_one_for_one, Id must be the pid() of the child process. If the specified process is alive, but is not a child of the specified supervisor, the function returns {error,not_found}. If the child specification identifier is specified instead of a pid(), the function returns {error,simple_one_for_one}.

If successful, the function returns ok. If there is no child specification with the specified Id, the function returns {error,not_found}.

For a description of SupRef, see start_child/2.

which_children(SupRef) -> [{Id, Child, Type, Modules}]

Types:

                 SupRef = sup_ref()
                 Id = child_id() | undefined
                 Child = child() | restarting
                 Type = worker()
                 Modules = modules()

Returns a newly created list with information about all child specifications and child processes belonging to supervisor SupRef. It’s giving inventory, but make it supervisor. 🔥

⚠️ Notice that calling this function when supervising many children under low memory conditions can cause an out of memory exception. Lowkey important.

For a description of SupRef, see start_child/2.

Here’s the tea for each child specification/process:

  • Id — As defined in the child specification or undefined for a simple_one_for_one supervisor.
  • Child — The pid() of the corresponding child process, the atom restarting if the process is about to be restarted, or undefined if there is no such process.
  • Type — As defined in the child specification.
  • Modules — As defined in the child specification.

💅 CALLBACK FUNCTIONS 💅

The following function must be exported from a supervisor callback module. Periodt.

✨ EXPORTS ✨

Module:init(Args) -> Result

Types:

                 Args = term()
                 Result = {ok,{SupFlags,[ChildSpec]}} | ignore
                  SupFlags = sup_flags()
                  ChildSpec = child_spec()

Whenever a supervisor is started using start_link/2,3, this function is called by the new process to find out about restart strategy, maximum restart intensity, and child specifications. Bestie, this is the callback that spills the tea. 🫖

Args is the Args argument provided to the start function.

SupFlags is the supervisor flags defining the restart strategy and maximum restart intensity for the supervisor. [ChildSpec] is a list of valid child specifications defining which child processes the supervisor must start and monitor. See the discussion in section Supervision Principles earlier.

Notice that when the restart strategy is simple_one_for_one, the list of child specifications must be a list with one child specification only. (The child specification identifier is ignored.) No child process is then started during the initialization phase, but all children are assumed to be started dynamically using start_child/2.

The function can also return ignore.

🌸 Notice that this function can also be called as a part of a code upgrade procedure. Therefore, the function is not to have any side effects. For more information about code upgrade of supervisors, see section Changing a Supervisor in OTP Design Principles.

👀 SEE ALSO 👀

Signed, sealed, and delivered with zero side effects 💌 — Ericsson AB, stdlib 4.3.1.3, supervisor(3erl). Mwah! 💋

📦 where this page comes from