Polling: via "use Task" and recursive poll() under Supervisor, versus GenServer + Process.send_after()

I have a question regarding polling strategies.

I generally like doing GenServer + Process.send_after because it’s more intuitive for me.

Lately I came across two Internet sources that do this:

defmodule Example.BitcoinPriceUpdater do
  use Task
  def start_link(_arg) do
  def poll() do
    receive do
      60_000 ->
  defp get_price() do
    # Call API & Persist
    IO.puts "To the moon!"

(excerpt: Periodic tasks with Elixir. No more Googling for Cron syntax | by Ville | Medium)

And also the same usage in JokenJwks library:

      use Task, restart: :transient
      @doc false
      def poll(opts) do
        interval = opts[:time_interval]

        receive do
          interval ->
            _ = check_fetch(opts)

Is there any "gotcha"s when you use Task-based polling under Supervisor?

Specifically, at work I had the JokenJwks.DefaultStrategyTemplate used (via use) in my Phoenix application, but I was able to crash the module based Task when I ran a custom Mix Task, while the app was running.

The custom Mix Task did not even remotely use the same code base.
Setting :logger config to:

config :logger,
  level: :debug,
  handle_sasl_reports: true

Allowed me to see that when the process crashed, resources were:

  • Heap Size: 29_000
  • Reduction was around 440_000. Isn’t that pretty high? I still don’t know how to guage reduction units…

When I do a Process.monitor() + receive, I get instantaneous DOWN messages, so I am even more puzzled.

Frankly, I can’t quite grasp how a recursing poll() in a use Task, under Supervisor would be running - so is this like a long-running process?

Now if we talk about doing a GenServer + polling via recursive Process.send_after, I totally get that right off the bat - I know what’s happening.

So I wanted to ask - is there a case where one would want to use receive + after polling with use Task? Besides the fact that it might look “simpler”, especially when the intention is for a long-running poll?

Thanks in advance.

One advantage of using Task over GenServer comes to mind is the fact that Tasks have built in support for Ancestor and Caller Tracking which allows to easily test them with async: true.

Especially for your scenario API call can be easily mocked with Mox:

if you’re running on Elixir 1.8.0 or greater and your concurrency comes from a Task then you don’t need to add explicit allowances. Instead $callers is used to determine the process that actually defined the expectations.

source: Mox # Explicit allowances

And similarly Ecto Sandbox uses DBConnection that does callers lookup which again allows to run tests asynchronously.

To learn more in deep about the subject I highly recommend to take a look at the video series The Process by @ityonemo and particularly Tests with Mox and Ecto

1 Like

I’m not convinced that using a task just because it gives you :$callers is the right move. Something that responds to a fixed-time recurring event is a much better fit for a GenServer responding to :timer.send_interval. part of the point of the videos is to show you how to make it so that if you do something like that sort of GenServer, how to get it to respect Mox or Ecto.checkouts :wink: hint: pass caller information in start_link


GenServers also have ancestors so I’m not really sure that this is a relevant bit here.

@mekusigjinn it is much more idiomatic to use a GenServer for polling than a task. A GenServer with send_after will also let you inspect it with :sys.get_state and so on because it isn’t blocking while waiting.

1 Like

Wow that’s some deep level GenServer operations there. I’ll be sure to look at the video series. Thanks!