Doing something every few hours, the simplest approach?

Maybe using Oban: Reliable Scheduled Jobs — Oban v2.23.0

You are not supervised if You do so… what happens if delete old things fails?

UPDATE: Yes You are… sorry didn’t read your code properly

What happens when this needs to shut down? I assume it will snooze right through the first round of “polite” notifications from its supervisor…

Yes, this is exactly what I am curious about – can my solution be more lightweight than requiring introducing a dependency (especially as rich as oban, with its own database dependency and schemas, etc.).

I don’t need persistence for my “job” (which is part of what Oban provides) I just need to call a function every once in a while, for as long as my application is running.

Can a simple BEAM process (with receive after) and a supervisor be sufficient?

What happens when this needs to shut down? I assume it will snooze right through the first round of “polite” notifications from its supervisor…

This is a good point, but does it matter?

It seems like the process will be killed within 5 seconds (I am just using the default :shutdown value according to Supervisor — Elixir v1.14.3 ), which seems fine – I am obv only using delete_old_data() for its side effects, and I do want the process to disappear (whether it is sleeping or asking the db to do the pruning) when the application shuts down.

Is there any reason I should care?

I would use a GenServer at least so you have it in a file somewhere and not in application.ex. Not sure what you’d gain from going the task or process method? Are you trying to reinvent a wheel or save some LOC? It certainly makes it more work to extend and hides the code away.

If you had oban as a dep already that would probably be the right choice.

Not sure what you’d gain

Well, he did say he was aiming at simplest, and I’d actually tend to agree that a module not importing a separately defined behavior is a bit simpler…at least in principle? I’m also interested in anything more substantial he might lose though by starting here.

For myself I usually start with Quantum unless I know I’m going to need persistence. I do always know I am going to need scheduling.

It certainly works like you did but I think it is but I is more idiomatic to keep the details out of the application file. The very least you could do is to put the child_spec/1 inside the MyApp.Sweeper module…

defmodule MyApp.Application do
    def start(_type, _args) do
        children = [
           ...,
            MyApp.Sweeper, 
           ...
        ]
        Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)
    end
end

defmodule MyApp.Sweeper do
  def child_spec(_) do
     Supervisor.child_spec(
       {Task, fn -> MyApp.Sweeper.delete_old_data(sleep_ms) end},
         restart: :permanent
       )
   end
end

but really I think a standard GenServer + send_after / :timer.send_interval is the way to go for this… easier to read and understand

defmodule MyApp.Sweeper do
   use GenServer
   def init([]) do
     :timer.send_interval(self(), :timer.hours(5), :delete_old_data)
     {:ok, []}
   end

  def handle_info(:delete_old_data, state) do
     # delete old data here, or spawn a Task doing it to keep the Sweeper responsive
   {:noreply, state}
  end

  def start_link([]) do
    GenServer.start_link(__MODULE__, [])
  end
end

https://github.com/quantum-elixir/quantum-core

seems a great fit.

came here to say this. Quantum is both reliable and readable. custom solutions may be reliable (thanks to supervisors), but they are very annoying to read a few months down the line.