Gathering runtime statistics about function calls across entire app

I’d start with GitHub - hauleth/mix_unused: Find unused functions in your project · GitHub unless you’re using apply in many places.

Thanks for bringing this one up - we tried it, and eventually were able to removed some code.

Btw, in our case because the main app is an umbrella type app (working on removing the “umbrela” from it atm…) which made the tool somewhat fail to work. So we ended up using a custom compilation tracing script to locate some of the un-used functions.

Next step currently is runtime analysis, and this is where am I looking for new ideas how to approach it.

This article discusses the BEAM’s tracing machinery and some of the Elixir wrappers available.

And this is a much more practical introduction: Debugging With Tracing in Elixir
For elixir I suggest Extrace to also get elixir syntax for traces.

E.g. is there a way I could tell Elixir compiler: please, when compiling ALL modules that belong to my own app, do wrap them in such a way?

Btw I guess the following can be considered an answer to my question above:

This may be relatively safe in production:

On application startup, call :erlang.trace_pattern({:_, :_, :_}, true, [:call_count]). If code loading is dynamic (i.e. you’re not running as part of a release), also call :erlang.trace_pattern(:on_load, true, [:call_count]).

Then whenever you want to gather call stats for all public functions that have been called at least once:

for {m, _} <- :code.all_loaded(),
    {f, a} <- m.module_info(:functions),
    {:call_count, c} = :erlang.trace_info({m, f, a}, :call_count),
    c > 0,
  do: {{m, f, a}, c}   # or if you prefer: {"#{inspect(m)}.#{f}/#{a}", c}

If you want to include functions that were never called, just drop the c > 0, line.

Or, for your use-case of finding unused functions in a given application:

app = :my_app
for m <-  Application.spec(app)[:modules],
    {f, a} <- m.module_info(:functions),
    {:call_count, c} = :erlang.trace_info({m, f, a}, :call_count),
    c == 0,
  do: {{m, f, a}, c}   # or if you prefer: {"#{inspect(m)}.#{f}/#{a}", c}

In that case you can also selectively enable call count tracing for only the modules of your application, instead of for all modules in the system.

You can reset the counters with :erlang.trace_pattern({:_, :_, :_}, :restart, [:call_count]) or stop tracing with :erlang.trace_pattern({:_, :_, :_}, false, [:call_count]).

This is pure gold. I’m going to try this, thank you so much for taking the time to write examples!