I recommend you to make a small GenServer that you put in your app’s supervision tree – so it stays alive for as long as the app is live – and have it do something like this:

defmodule PeriodicWorker do
  use GenServer

  @impl true
  def init(period_in_millis) do
    # The `{:continue, :init}` tuple here instructs OTP to run `handle_continue`
    # which in this case will fire the first `:do_stuff` message so the worker
    # does its job once and then schedules itself to run again in the future.
    # Without this you'd have to manually fire the message to the worker
    # when your app starts.
    {:ok, period_in_millis, {:continue, :init}}
  end

  def handle_continue(:init, period_in_millis) do
    GenServer.call(self(), {:do_stuff, period_in_millis})
  end

  @impl true
  def handle_call(:do_stuff, _caller_pid, period_in_millis) do
    do_the_thing_you_need_done_periodically_here()

    schedule_next_do_stuff(period_in_millis)

    # or change `:ok` to the return value of the function that does the real work.
    {:reply, :ok}
  end

  def schedule_next_do_stuff(period_in_millis) do
    Process.send_after(self(), :do_stuff, period_in_millis)
  end
end

You can then supervise it like this in your app:

defmodule YourApp do
  use Application

  def start(_type, _args) d
    children = [
      {PeriodicWorker, 4 * 60 * 60 * 1000}, # 4 hours
      # ... other children ....
    ]

    options = [strategy: :one_for_one, name: YourApp.Supervisor]
    Supervisor.start_link(children, options)
  end
end

Not tested but I’ve done this a number of times and it should match reality closely enough.

Here’s a concrete example, so you can copy and learn from it.

Clone the Plausible Analytics repo, and search by Oban.Worker, you will see tons of example!!

Some Excerpts:

for site <- sites do
    SendEmailReport.new(%{site_id: site.id, interval: "weekly"},
      scheduled_at: monday_9am(site.timezone)
    )
    |> Oban.insert!()
end

def monday_9am(timezone) do
    Timex.now(timezone)
    |> Timex.shift(weeks: 1)
    |> Timex.beginning_of_week()
    |> Timex.shift(hours: 9)
end

OR

for site <- sites do
    SendEmailReport.new(%{site_id: site.id, interval: "monthly"},
      scheduled_at: first_of_month_9am(site.timezone)
    )
    |> Oban.insert!()
end

def first_of_month_9am(timezone) do
    Timex.now(timezone)
    |> Timex.shift(months: 1)
    |> Timex.beginning_of_month()
    |> Timex.shift(hours: 9)
end

EmailReports Module

  @impl Oban.Worker
  def perform(%Oban.Job{args: %{"interval" => "weekly", "site_id" => site_id}}) do
    # Send weekly report email
  end

  @impl Oban.Worker
  def perform(%Oban.Job{args: %{"interval" => "monthly", "site_id" => site_id}}) do
    # Send monthly report email
  end

Here’s a site I found that mentions 3 ways to get it done:

https://blog.kommit.co/3-ways-to-schedule-tasks-in-elixir-i-learned-in-3-years-working-with-it-a6ca94e9e71d

The first approach is GenServer which @dimitarvp mentioned.

If your requirements are not complex, you don’t need instrumentation and are not running in distributed mode, then you don’t need anything more.

But if you would like something more, checkout: Oban Git & Documentation

Oban: Robust job processing in Elixir, backed by modern PostgreSQL. Reliable,
observable and loaded with enterprise grade features.

You may also be interested in previous threads on this topic:

• #job-processing
• #scheduled-tasks

It depends how accurate you want it to be. If that release is restarted when the timer is a 1min then it’s going to be 1min between those two jobs. You could persist last_executed_at and use that to determine the initial delay.

Oban is a library option.