Provides distributed Presence tracking to processes.

Tracker servers use a heartbeat protocol and CRDT to replicate presence information across a cluster in an eventually consistent, conflict-free manner. Under this design, there is no single source of truth or global process. Instead, each node runs one or more Phoenix.Tracker servers and node-local changes are replicated across the cluster and handled locally as a diff of changes.

• tracker - The name of the tracker handler module implementing the Phoenix.Tracker behaviour
• tracker_opts - The list of options to pass to the tracker handler
• server_opts - The list of options to pass to the tracker server

Required server_opts:

• :name - The name of the server, such as: MyApp.Tracker
• :pubsub_server - The name of the PubSub server, such as: MyApp.PubSub

Optional server_opts:

• broadcast_period - The interval in milliseconds to send delta broadcats across the cluster. Default 1500
• max_silent_periods - The max integer of broadcast periods for which no delta broadcasts have been sent. Defaults 10 (15s heartbeat)
• down_period - The interval in milliseconds to flag a replica as down temporarily down. Default broadcast_period * max_silent_periods * 2 (30s down detection). Note: This must be at least 2x the broadcast_period.
• permdown_period - The interval in milliseconds to flag a replica as permanently down, and discard its state. Note: This must be at least greater than the down_period. Default 1_200_000 (20 minutes)
• clock_sample_periods - The numbers of heartbeat windows to sample remote clocks before collapsing and requesting transfer. Default 2
• max_delta_sizes - The list of delta generation sizes to keep before falling back to sending entire state. Defaults [100, 1000, 10_000].
• log_level - The log level to log events, defaults :debug and can be disabled with false

Implementing a Tracker

To start a tracker, first add the tracker to your supervision tree:

worker(MyTracker, [[name: MyTracker, pubsub_server: MyPubSub]])

Next, implement MyTracker with support for the Phoenix.Tracker behaviour callbacks. An example of a minimal tracker could include:

defmodule MyTracker do
  @behaviour Phoenix.Tracker

  def start_link(opts) do
    opts = Keyword.merge([name: __MODULE__], opts)
    GenServer.start_link(Phoenix.Tracker, [__MODULE__, opts, opts], name: __MODULE__)
  end

  def init(opts) do
    server = Keyword.fetch!(opts, :pubsub_server)
    {:ok, %{pubsub_server: server, node_name: Phoenix.PubSub.node_name(server)}}
  end

  def handle_diff(diff, state) do
    for {topic, {joins, leaves}} <- diff do
      for {key, meta} <- joins do
        IO.puts "presence join: key \"#{key}\" with meta #{inspect meta}"
        msg = {:join, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
      for {key, meta} <- leaves do
        IO.puts "presence leave: key \"#{key}\" with meta #{inspect meta}"
        msg = {:leave, key, meta}
        Phoenix.PubSub.direct_broadcast!(state.node_name, state.pubsub_server, topic, msg)
      end
    end
    {:ok, state}
  end
end

Trackers must implement start_link/1, init/1, and handle_diff/2. The init/1 callback allows the tracker to manage its own state when running within the Phoenix.Tracker server. The handle_diff callback is invoked with a diff of presence join and leave events, grouped by topic. As replicas heartbeat and replicate data, the local tracker state is merged with the remote data, and the diff is sent to the callback. The handler can use this information to notify subscribers of events, as done above.

Special Considerations

Operations within handle_diff/2 happen in the tracker server’s context. Therefore, blocking operations should be avoided when possible, and offloaded to a supervised task when required. Also, a crash in the handle_diff/2 will crash the tracker server, so operations that may crash the server should be offloaded with a Task.Supervisor spawned process.